@azure-tools/typespec-ts 0.37.0 → 0.38.0

package/src/modular/helpers/classicalOperationHelpers.ts

@@ -74,21 +74,26 @@ export function getClassicalOperation(
     .filter((i) => i.getName() === interfaceName)[0];
   const properties: OptionalKind<PropertySignatureStructure>[] = [];
   if (layer !== prefixes.length - 1) {
-    properties.push({
-      kind: StructureKind.PropertySignature,
-      name: normalizeName(
-        (layer === prefixes.length - 1
-          ? prefixes[layer]
-          : prefixes[layer + 1]) ?? "",
-        NameType.Property
-      ),
-      type: `${getClassicalLayerPrefix(
-        prefixes,
-        NameType.Interface,
+    const name = normalizeName(
+      (layer === prefixes.length - 1 ? prefixes[layer] : prefixes[layer + 1]) ??
         "",
-        layer + 1
-      )}Operations`
-    });
+      NameType.Property
+    );
+    if (
+      !properties.some((x) => x.name === name) &&
+      !(existInterface && existInterface.getProperty(name))
+    ) {
+      properties.push({
+        kind: StructureKind.PropertySignature,
+        name,
+        type: `${getClassicalLayerPrefix(
+          prefixes,
+          NameType.Interface,
+          "",
+          layer + 1
+        )}Operations`
+      });
+    }
   } else {
     operationDeclarations.forEach((d) => {
       properties.push({
@@ -124,13 +129,13 @@ export function getClassicalOperation(
 
   if (layer === prefixes.length - 1) {
     classicFile.addFunction({
-      name: `get${getClassicalLayerPrefix(
+      name: `_get${getClassicalLayerPrefix(
         prefixes,
         NameType.Interface,
         "",
         layer
       )}`,
-      isExported: true,
+      isExported: false,
       parameters: [
         {
           name: "context",
@@ -164,7 +169,7 @@ export function getClassicalOperation(
     });
   }
 
-  const operationFunctionName = `get${getClassicalLayerPrefix(
+  const operationFunctionName = `_get${getClassicalLayerPrefix(
     prefixes,
     NameType.Interface,
     "",
@@ -176,27 +181,41 @@ export function getClassicalOperation(
   if (existFunction) {
     const returnStatement = existFunction.getBodyText();
     if (returnStatement) {
-      let statement = `,
-      ...get${getClassicalLayerPrefix(
+      let statement: string | undefined = undefined;
+      if (layer !== prefixes.length - 1) {
+        const name = normalizeName(
+          prefixes[layer + 1] ?? "FIXME",
+          NameType.Property
+        );
+
+        // HACK: check if the statement includes a group of this name already to prevent an operation group appearing multiple times
+        // TODO: would be good to refactor so that we have an intermediate data structure before generating the return statement
+        if (!returnStatement.includes(`${name}:`)) {
+          statement = `,
+          ${normalizeName(
+            prefixes[layer + 1] ?? "FIXME",
+            NameType.Property
+          )}: _get${getClassicalLayerPrefix(
+            prefixes,
+            NameType.Interface,
+            "",
+            layer + 1
+          )}Operations(context)}`;
+        }
+      } else {
+        statement = `,
+      ..._get${getClassicalLayerPrefix(
         prefixes,
         NameType.Interface,
         "",
         layer + 1
       )}Operations(context)}`;
-      if (layer !== prefixes.length - 1) {
-        statement = `,
-        ${normalizeName(
-          prefixes[layer + 1] ?? "FIXME",
-          NameType.Property
-        )}: get${getClassicalLayerPrefix(
-          prefixes,
-          NameType.Interface,
-          "",
-          layer + 1
-        )}Operations(context)}`;
       }
-      const newReturnStatement = returnStatement.replace(/}$/, statement);
-      existFunction.setBodyText(newReturnStatement);
+
+      if (statement) {
+        const newReturnStatement = returnStatement.replace(/}$/, statement);
+        existFunction.setBodyText(newReturnStatement);
+      }
     }
   } else {
     const functions = {
@@ -220,7 +239,7 @@ export function getClassicalOperation(
             ${normalizeName(
               prefixes[layer + 1] ?? "FIXME",
               NameType.Property
-            )}: get${getClassicalLayerPrefix(
+            )}: _get${getClassicalLayerPrefix(
               prefixes,
               NameType.Interface,
               "",
@@ -228,7 +247,7 @@ export function getClassicalOperation(
             )}Operations(context)   
       }`
           : `return {
-        ...get${getClassicalLayerPrefix(
+        ..._get${getClassicalLayerPrefix(
           prefixes,
           NameType.Interface,
           "",

package/src/modular/helpers/clientHelpers.ts

@@ -17,7 +17,7 @@ import {
   PackageFlavor
 } from "@azure-tools/rlc-common";
 import { SdkContext } from "../../utils/interfaces.js";
-import { getClientName } from "./namingHelpers.js";
+import { getClassicalClientName } from "./namingHelpers.js";
 import { getTypeExpression } from "../type-expressions/get-type-expression.js";
 import { isCredentialType } from "./typeHelpers.js";
 
@@ -106,10 +106,10 @@ export function getClientParametersDeclaration(
     apiVersionAsRequired: false
   }
 ): OptionalKind<ParameterDeclarationStructure>[] {
-  const name = getClientName(client);
+  const name = getClassicalClientName(client);
   const optionsParam = {
     name: "options",
-    type: `${name}ClientOptionalParams`,
+    type: `${name}OptionalParams`,
     initializer: "{}"
   };
 

package/src/modular/helpers/operationHelpers.ts

@@ -168,7 +168,7 @@ export function getDeserializePrivateFunction(
   );
   statements.push(
     `if(!expectedStatuses.includes(result.status)){`,
-    `throw ${createRestErrorReference}(result);`,
+    `${getExceptionThrowStatement(context, operation)}`,
     "}"
   );
   const deserializedType = isLroOnly
@@ -186,7 +186,7 @@ export function getDeserializePrivateFunction(
   if (isLroOnly && lroSubPath) {
     statements.push(
       `if(${deserializedRoot.split(".").join("?.")} === undefined) {
-        throw createRestError(\`Expected a result in the response at position "${deserializedRoot}"\`, result);
+        throw ${createRestErrorReference}(\`Expected a result in the response at position "${deserializedRoot}"\`, result);
       }
       `
     );
@@ -228,6 +228,103 @@ export function getDeserializePrivateFunction(
   };
 }
 
+interface ExceptionThrowDetail {
+  start: number;
+  end?: number;
+  deserializer: string;
+}
+
+interface OperationExceptionDetails {
+  customized: ExceptionThrowDetail[];
+  defaultDeserializer?: string;
+}
+
+function getExceptionDetails(
+  context: SdkContext,
+  operation: ServiceOperation
+): OperationExceptionDetails {
+  const customized: ExceptionThrowDetail[] = [];
+  let defaultDeserializer: string | undefined;
+  for (const exception of operation.operation.exceptions) {
+    if (!exception.type) {
+      continue;
+    }
+    const statusCode = exception.statusCodes;
+    const deserializeFunctionName = buildModelDeserializer(
+      context,
+      exception.type,
+      false,
+      true
+    );
+    if (
+      !deserializeFunctionName ||
+      typeof deserializeFunctionName !== "string"
+    ) {
+      continue;
+    }
+    if (statusCode === "*") {
+      defaultDeserializer = deserializeFunctionName;
+    } else if (typeof statusCode === "number") {
+      customized.push({
+        start: statusCode,
+        deserializer: deserializeFunctionName
+      });
+    } else {
+      customized.push({
+        start: statusCode.start,
+        end: statusCode.end,
+        deserializer: deserializeFunctionName
+      });
+    }
+  }
+  return { customized, defaultDeserializer };
+}
+
+function getExceptionThrowStatement(
+  context: SdkContext,
+  operation: ServiceOperation
+) {
+  const statements = [];
+  const createRestErrorReference = resolveReference(
+    useDependencies().createRestError
+  );
+  const { customized, defaultDeserializer } = getExceptionDetails(
+    context,
+    operation
+  );
+  if (customized.length > 0) {
+    statements.push(`const error = ${createRestErrorReference}(result);`);
+    statements.push(`const statusCode = Number.parseInt(result.status);`);
+    const stats: string[] = customized.map((exception) => {
+      if (exception.end) {
+        return `if(statusCode >= ${exception.start} && statusCode <= ${exception.end}) {
+              error.details = ${exception.deserializer}(result.body);
+          }`;
+      } else {
+        return `if(statusCode === ${exception.start}) {
+             error.details = ${exception.deserializer}(result.body);
+          }`;
+      }
+    });
+    statements.push(stats.join("\nelse "));
+    if (defaultDeserializer) {
+      statements.push(`else {
+        error.details = ${defaultDeserializer}(result.body);
+      }`);
+    }
+    statements.push("throw error;");
+  } else {
+    if (defaultDeserializer) {
+      statements.push(`const error = ${createRestErrorReference}(result);
+      error.details = ${defaultDeserializer}(result.body);`);
+      statements.push("throw error;");
+    } else {
+      statements.push(`throw ${createRestErrorReference}(result);`);
+    }
+  }
+  return statements.join("\n");
+}
+
 function getOptionalParamsName(
   parameters: OptionalKind<ParameterDeclarationStructure>[]
 ) {
@@ -795,7 +892,7 @@ function getRequired(context: SdkContext, param: SdkModelPropertyType) {
   const serializedName = getPropertySerializedName(param);
   const clientValue = `${param.onClient ? "context." : ""}${param.name}`;
   if (param.type.kind === "model") {
-    const { propertiesStr } = getRequestModelMapping(
+    const propertiesStr = getRequestModelMapping(
       context,
       { ...param.type, optional: param.optional },
       clientValue
@@ -834,15 +931,12 @@ function getOptional(
   const serializedName = getPropertySerializedName(param);
   const paramName = `${param.onClient ? "context." : `${optionalParamName}?.`}${param.name}`;
   if (param.type.kind === "model") {
-    const { propertiesStr, directAssignment } = getRequestModelMapping(
+    const propertiesStr = getRequestModelMapping(
       context,
       { ...param.type, optional: param.optional },
       paramName + "?."
     );
-    const serializeContent =
-      directAssignment === true
-        ? propertiesStr.join(",")
-        : `{${propertiesStr.join(",")}}`;
+    const serializeContent = `{${propertiesStr.join(",")}}`;
     return `"${serializedName}": ${serializeContent}`;
   }
   return `"${serializedName}": ${serializeRequestValue(
@@ -948,72 +1042,86 @@ function getNullableCheck(name: string, type: SdkType) {
   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
- */
-interface RequestModelMappingResult {
-  propertiesStr: string[];
-  directAssignment?: boolean;
+export function getSerializationExpression(
+  context: SdkContext,
+  property: SdkModelPropertyType,
+  propertyPath: string
+): string {
+  const dot = propertyPath.endsWith("?") ? "." : "";
+  const propertyPathWithDot = `${propertyPath ? `${propertyPath}${dot}` : `${dot}`}`;
+  const nullOrUndefinedPrefix = getPropertySerializationPrefix(
+    context,
+    property,
+    propertyPath
+  );
+
+  const propertyFullName = getPropertyFullName(
+    context,
+    property,
+    propertyPathWithDot
+  );
+  const serializeFunctionName = buildModelSerializer(
+    context,
+    getNullableValidType(property.type),
+    false,
+    true
+  );
+  if (serializeFunctionName) {
+    return `${nullOrUndefinedPrefix}${serializeFunctionName}(${propertyFullName})`;
+  } else if (isAzureCoreErrorType(context.program, property.type.__raw)) {
+    return `${nullOrUndefinedPrefix}${propertyFullName}`;
+  } else {
+    return serializeRequestValue(
+      context,
+      property.type,
+      propertyFullName,
+      !property.optional,
+      getEncodeForType(property.type)
+    );
+  }
 }
-export function getRequestModelMapping(
+
+export function getRequestModelProperties(
   context: SdkContext,
   modelPropertyType: SdkModelType & { optional?: boolean },
   propertyPath: string = "body"
-): RequestModelMappingResult {
-  const props: string[] = [];
+): Array<[string, string]> {
+  const props: [string, string][] = [];
   const allParents = getAllAncestors(modelPropertyType);
   const properties: SdkModelPropertyType[] =
     getAllProperties(modelPropertyType, allParents) ?? [];
   if (properties.length <= 0) {
-    return { propertiesStr: [] };
+    return [];
   }
   for (const property of properties) {
     if (property.kind === "property" && isReadOnly(property)) {
       continue;
     }
-    const dot = propertyPath.endsWith("?") ? "." : "";
-    const serializedName = getPropertySerializedName(property);
-    const propertyPathWithDot = `${propertyPath ? `${propertyPath}${dot}` : `${dot}`}`;
-    const nullOrUndefinedPrefix = getPropertySerializationPrefix(
-      context,
-      property,
-      propertyPath
-    );
 
-    const propertyFullName = getPropertyFullName(
-      context,
-      property,
-      propertyPathWithDot
-    );
-    const serializeFunctionName = buildModelSerializer(
-      context,
-      getNullableValidType(property.type),
-      false,
-      true
-    );
-    if (serializeFunctionName) {
-      props.push(
-        `"${serializedName}": ${nullOrUndefinedPrefix}${serializeFunctionName}(${propertyFullName})`
-      );
-    } else if (isAzureCoreErrorType(context.program, property.type.__raw)) {
-      props.push(
-        `"${serializedName}": ${nullOrUndefinedPrefix}${propertyFullName}`
-      );
-    } else {
-      const serializedValue = serializeRequestValue(
-        context,
-        property.type,
-        propertyFullName,
-        !property.optional,
-        getEncodeForType(property.type)
-      );
-      props.push(`"${serializedName}": ${serializedValue}`);
-    }
+    props.push([
+      getPropertySerializedName(property)!,
+      getSerializationExpression(context, property, propertyPath)
+    ]);
   }
 
-  return { propertiesStr: props };
+  return props;
+}
+
+/**
+ *
+ * This function helps translating an HLC request to RLC request,
+ * extracting properties from body and headers and building the RLC response object
+ */
+export function getRequestModelMapping(
+  context: SdkContext,
+  modelPropertyType: SdkModelType & { optional?: boolean },
+  propertyPath: string = "body"
+): string[] {
+  return getRequestModelProperties(
+    context,
+    modelPropertyType,
+    propertyPath
+  ).map(([name, value]) => `"${name}": ${value}`);
 }
 
 function getPropertySerializedName(property: SdkModelPropertyType) {
@@ -1164,7 +1272,7 @@ export function serializeRequestValue(
         return `${clientValue} as any`;
       }
     case "model": // this is to build serialization logic for spread model types
-      return `{${getRequestModelMapping(context, type, "").propertiesStr.join(",")}}`;
+      return `{${getRequestModelMapping(context, type, "").join(",")}}`;
     case "nullable":
       return serializeRequestValue(
         context,

package/src/modular/serialization/buildDeserializerFunction.ts

@@ -34,7 +34,8 @@ export function buildModelDeserializer(
     if (
       !type.usage ||
       (type.usage !== undefined &&
-        (type.usage & UsageFlags.Output) !== UsageFlags.Output)
+        (type.usage & UsageFlags.Output) !== UsageFlags.Output &&
+        (type.usage & UsageFlags.Exception) !== UsageFlags.Exception)
     ) {
       return undefined;
     }

package/src/modular/serialization/buildSerializerFunction.ts

@@ -10,7 +10,13 @@ import {
 import { toCamelCase, toPascalCase } from "../../utils/casingUtils.js";
 
 import { SdkContext } from "../../utils/interfaces.js";
-import { getRequestModelMapping } from "../helpers/operationHelpers.js";
+import {
+  getAllAncestors,
+  getAllProperties,
+  getPropertyFullName,
+  getRequestModelMapping,
+  getSerializationExpression
+} from "../helpers/operationHelpers.js";
 import { normalizeModelName } from "../emitModels.js";
 import { NameType } from "@azure-tools/rlc-common";
 import { isAzureCoreErrorType } from "../../utils/modelUtils.js";
@@ -19,6 +25,9 @@ import {
   isSupportedSerializeType,
   ModelSerializeOptions
 } from "./serializeUtils.js";
+import { MultipartHelpers } from "../static-helpers-metadata.js";
+import { resolveReference } from "../../framework/reference.js";
+import { isOrExtendsHttpFile } from "@typespec/http";
 
 export function buildModelSerializer(
   context: SdkContext,
@@ -43,7 +52,10 @@ export function buildModelSerializer(
       // throw new Error(`NYI Serialization of anonymous types`);
       return undefined;
     }
-    if (isAzureCoreErrorType(context.program, type.__raw!)) {
+    if (
+      isAzureCoreErrorType(context.program, type.__raw!) ||
+      isOrExtendsHttpFile(context.program, type.__raw!)
+    ) {
       return undefined;
     }
   }
@@ -331,37 +343,90 @@ function buildModelTypeSerializer(
     statements: ["return item;"]
   };
 
-  // This is only handling the compatibility mode, will need to update when we handle additionalProperties property.
-  const additionalPropertiesSpread = hasAdditionalProperties(type)
-    ? "...item"
-    : "";
+  if (
+    (type.usage & UsageFlags.Input) === UsageFlags.Input &&
+    (type.usage & UsageFlags.MultipartFormData) === UsageFlags.MultipartFormData
+  ) {
+    // For MFD models, serialize into an array of parts
+    // TODO: cleaner abstraction, quite a bit of duplication with the non-MFD stuff here
+    const parts: string[] = [];
 
-  const { directAssignment, propertiesStr } = getRequestModelMapping(
-    context,
-    type,
-    "item"
-  );
-  if (additionalPropertiesSpread) {
-    propertiesStr.unshift(additionalPropertiesSpread);
-  }
-  const serializeContent =
-    directAssignment === true
-      ? propertiesStr.join(",")
-      : `{${propertiesStr.join(",")}}`;
+    const properties = getAllProperties(type, getAllAncestors(type));
+    for (const property of properties) {
+      if (property.kind !== "property") {
+        continue;
+      }
+      const expr = getSerializationExpression(context, property, "item");
+
+      let partDefinition: string;
+      if (property.isMultipartFileInput) {
+        const createFilePartDescriptorDefinition = resolveReference(
+          MultipartHelpers.createFilePartDescriptor
+        );
+
+        const itemPath = property.multipartOptions?.isMulti
+          ? "x"
+          : getPropertyFullName(context, property, "item");
+        partDefinition = `${createFilePartDescriptorDefinition}("${property.serializedName}", ${itemPath}, )`;
+
+        // If the TypeSpec doesn't specify a default content type, TCGC will infer a default of "*/*".
+        // In this case, we actually want the content type to be left unset so that Core will take care of
+        // setting the content type correctly.
+        const contentType =
+          property.multipartOptions?.defaultContentTypes?.[0] === "*/*"
+            ? undefined
+            : property.multipartOptions?.defaultContentTypes?.[0];
 
-  const output = [];
+        if (property.multipartOptions?.isMulti) {
+          partDefinition = `...(item["${property.serializedName}"].map((x: unknown) => ${createFilePartDescriptorDefinition}("${property.serializedName}", x${contentType ? `", ${contentType}"` : ""})))`;
+        } else {
+          partDefinition = `${createFilePartDescriptorDefinition}("${property.serializedName}", item["${property.serializedName}"]${contentType ? `, "${contentType}"` : ""})`;
+        }
+      } else if (property.multipartOptions?.isMulti) {
+        partDefinition = `...((${expr}).map((x: unknown) => ({ name: "${property.serializedName}", body: x })))`;
+      } else {
+        partDefinition = `{ name: "${property.serializedName}", body: (${expr}) }`;
+      }
+
+      if (property.optional) {
+        parts.push(
+          `...(${getPropertyFullName(context, property, "item")} === undefined ? [] : [${partDefinition}])`
+        );
+      } else {
+        parts.push(partDefinition);
+      }
+
+      // TODO: How to handle additionalProperties for MFD?
+    }
+
+    serializerFunction.statements = [`return [${parts.join(",")}]`];
+  } else {
+    // This is only handling the compatibility mode, will need to update when we handle additionalProperties property.
+    const additionalPropertiesSpread = hasAdditionalProperties(type)
+      ? "...item"
+      : "";
 
-  // don't emit a serializer if there is nothing to serialize
-  if (propertiesStr.length) {
-    output.push(`
+    const propertiesStr = getRequestModelMapping(context, type, "item");
+
+    if (additionalPropertiesSpread) {
+      propertiesStr.unshift(additionalPropertiesSpread);
+    }
+    const serializeContent = `{${propertiesStr.join(",")}}`;
+
+    const output = [];
+
+    // don't emit a serializer if there is nothing to serialize
+    if (propertiesStr.length) {
+      output.push(`
         return ${serializeContent}
       `);
-  } else {
-    output.push(`
+    } else {
+      output.push(`
         return item;
       `);
+    }
+    serializerFunction.statements = output;
   }
-  serializerFunction.statements = output;
   return serializerFunction;
 }
 

package/src/modular/static-helpers-metadata.ts

@@ -71,3 +71,16 @@ export const PollingHelpers = {
     location: "pollingHelpers.ts"
   }
 } as const;
+
+export const MultipartHelpers = {
+  FileContents: {
+    kind: "typeAlias",
+    name: "FileContents",
+    location: "multipartHelpers.ts"
+  },
+  createFilePartDescriptor: {
+    kind: "function",
+    name: "createFilePartDescriptor",
+    location: "multipartHelpers.ts"
+  }
+} as const;

package/src/transform/transfromRLCOptions.ts

@@ -5,7 +5,8 @@ import {
   PackageDetails,
   PackageFlavor,
   RLCOptions,
-  ServiceInfo
+  ServiceInfo,
+  isAzurePackage
 } from "@azure-tools/rlc-common";
 import {
   getHttpOperationWithCache,
@@ -32,6 +33,15 @@ export function transformRLCOptions(
     emitterOptions,
     dpgContext.generationPathDetail?.rootDir ?? ""
   );
+  if (
+    !isAzurePackage({ options }) &&
+    emitterOptions.isModularLibrary !== false
+  ) {
+    options.isModularLibrary = true;
+  }
+  if (dpgContext.arm && emitterOptions.isModularLibrary !== false) {
+    options.isModularLibrary = true;
+  }
   const batch = getRLCClients(dpgContext);
   options.batch = batch;
   return options;