feat: add multipart/form-data

Author: Copilot

packages/http-client-csharp/emitter/src/constants.ts

@@ -23,3 +23,9 @@ export const _minSupportedDotNetSdkVersion = 8;
  * @internal
  */
 export const _defaultGeneratorName = "ScmCodeModelGenerator";
+
+/**
+ * The cross-language definition id for the TypeSpec HTTP File model.
+ * @internal
+ */
+export const _httpFileCrossLanguageDefinitionId = "TypeSpec.Http.File";

packages/http-client-csharp/emitter/src/lib/type-converter.ts

@@ -21,6 +21,7 @@ import {
   UsageFlags,
 } from "@azure-tools/typespec-client-generator-core";
 import { createDiagnosticCollector, Diagnostic, Model, NoTarget } from "@typespec/compiler";
+import { _httpFileCrossLanguageDefinitionId } from "../constants.js";
 import { CSharpEmitterContext } from "../sdk-context.js";
 import {
   InputArrayType,
@@ -216,6 +217,7 @@ function fromSdkModelType(
     external: fromSdkExternalTypeInfo(modelType),
     serializationOptions: modelType.serializationOptions,
     isExactName: modelType.isExactName,
+    isFileType: modelType.crossLanguageDefinitionId === _httpFileCrossLanguageDefinitionId,
   } as InputModelType;
 
   sdkContext.__typeCache.updateSdkTypeReferences(modelType, inputModelType);
@@ -295,6 +297,17 @@ function fromSdkModelProperty(
     isExactName: sdkProperty.isExactName,
   } as InputModelProperty;
 
+  if (sdkProperty.serializationOptions?.multipart?.isFilePart === true) {
+    if (property.type.kind === "model" || property.type.kind === "bytes") {
+      property.type.isFileType = true;
+    } else if (
+      property.type.kind === "array" &&
+      (property.type.valueType.kind === "model" || property.type.valueType.kind === "bytes")
+    ) {
+      property.type.valueType.isFileType = true;
+    }
+  }
+
   if (property) {
     sdkContext.__typeCache.updateSdkPropertyReferences(sdkProperty, property);
   }

packages/http-client-csharp/emitter/src/type/input-type.ts

@@ -88,6 +88,7 @@ export interface InputPrimitiveType extends InputTypeBase {
   encode?: string; // In TCGC this is required, and when there is no encoding, it just has the same value as kind
   crossLanguageDefinitionId: string;
   baseType?: InputPrimitiveType;
+  isFileType?: boolean;
 }
 
 export interface InputLiteralType extends InputTypeBase {
@@ -166,6 +167,7 @@ export interface InputModelType extends InputTypeBase {
   serializationOptions: SerializationOptions;
   /** Whether the name should be used exactly as-is, without casing transformations. */
   isExactName?: boolean;
+  isFileType: boolean;
 }
 
 export interface InputPropertyTypeBase extends DecoratedType {

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Primitives/MultipartSerialization.cs

@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System.Collections.Generic;
+using Microsoft.TypeSpec.Generator.Input;
+
+namespace Microsoft.TypeSpec.Generator.ClientModel.Primitives
+{
+    /// <summary>
+    /// Represents multipart/form-data serialization options for a property.
+    /// </summary>
+    public class MultipartSerialization
+    {
+        public MultipartSerialization(InputMultipartOptions options)
+        {
+            Name = options.Name;
+            IsFilePart = options.IsFilePart;
+            IsMulti = options.IsMulti;
+            DefaultContentTypes = options.DefaultContentTypes;
+            Filename = options.Filename;
+            ContentType = options.ContentType;
+        }
+
+        /// <summary> Gets the serialized name of the part. </summary>
+        public string Name { get; }
+
+        /// <summary> Gets a value indicating whether the part represents a file. </summary>
+        public bool IsFilePart { get; }
+
+        /// <summary> Gets a value indicating whether the part represents a collection of files. </summary>
+        public bool IsMulti { get; }
+
+        /// <summary> Gets the default media types declared for this part. </summary>
+        public IReadOnlyList<string> DefaultContentTypes { get; }
+
+        /// <summary> Gets the file's filename property, if any. </summary>
+        public InputModelProperty? Filename { get; }
+
+        /// <summary> Gets the file's content type property, if any. </summary>
+        public InputModelProperty? ContentType { get; }
+    }
+}

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Primitives/ScmKnownParameters.cs

@@ -62,7 +62,24 @@ public static ParameterProvider ClientOptions(CSharpType clientOptionsType)
             DefaultValue = Static(typeof(DateTimeOffset)).Property(nameof(DateTimeOffset.Now))
         };
 
-        public static readonly ParameterProvider ContentType = new("contentType", $"The contentType to use which has the multipart/form-data boundary.", typeof(string), wireInfo: new PropertyWireInformation(SerializationFormat.Default, true, false, false, false, "Content-Type", false, false));
+        private const string ContentTypeParameterName = "contentType";
+        private static readonly FormattableString ContentTypeDescription = $"The contentType to use which has the multipart/form-data boundary.";
+        private static readonly PropertyWireInformation ContentTypeWireInfo = new(SerializationFormat.Default, true, false, false, false, "Content-Type", false, false);
+
+        public static readonly ParameterProvider ContentType = new(
+            ContentTypeParameterName,
+            ContentTypeDescription,
+            typeof(string),
+            wireInfo: ContentTypeWireInfo)
+        {
+            Validation = ParameterValidationType.AssertNotNullOrEmpty,
+        };
+
+        public static readonly ParameterProvider OptionalContentType = new(
+            ContentTypeParameterName,
+            ContentTypeDescription,
+            typeof(string),
+            wireInfo: ContentTypeWireInfo);
 
         public static readonly ParameterProvider NextPage =
             new ParameterProvider("nextPage", $"The url of the next page of responses.", typeof(Uri));

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Primitives/ScmSerializationOptions.cs

@@ -16,10 +16,15 @@ public ScmSerializationOptions(InputSerializationOptions inputSerializationOptio
             Xml = inputSerializationOptions.Xml != null
                 ? new(inputSerializationOptions.Xml)
                 : null;
+            Multipart = inputSerializationOptions.Multipart != null
+                ? new(inputSerializationOptions.Multipart)
+                : null;
         }
 
         public JsonSerialization? Json { get; }
 
         public XmlSerialization? Xml { get; }
+
+        public MultipartSerialization? Multipart { get; }
     }
 }

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ModelSerializationExtensionsDefinition.Xml.cs

@@ -2,7 +2,9 @@
 // Licensed under the MIT License.
 
 using System;
+using System.ClientModel;
 using System.ClientModel.Primitives;
+using System.Collections.Generic;
 using System.IO;
 using System.Xml;
 using System.Xml.Linq;
@@ -14,6 +16,7 @@
 using Microsoft.TypeSpec.Generator.Statements;
 using static Microsoft.TypeSpec.Generator.Snippets.Snippet;
 
+#pragma warning disable SCME0004 // FileBinaryContent is evaluation-only.
 namespace Microsoft.TypeSpec.Generator.ClientModel.Providers
 {
     public sealed partial class ModelSerializationExtensionsDefinition
@@ -256,7 +259,78 @@ private MethodProvider BuildXmlWriteObjectValueMethodProvider()
             var defaultCase = SwitchCaseStatement.Default(
                 Throw(New.NotSupportedException(new FormattableStringExpression("Not supported type {0}", [new TypeOfExpression(_t)]))));
 
-            var body = new SwitchStatement(value, [persistableModelCase, defaultCase]);
+            var cases = new List<SwitchCaseStatement> { persistableModelCase };
+
+            if (HasFileBinaryContentXmlModel)
+            {
+                var fileBinaryContentCase = new SwitchCaseStatement(
+                    Declare("fileBinaryContent", typeof(FileBinaryContent), out var fileBinaryContentVar),
+                    new MethodBodyStatement[]
+                    {
+                        writer.Invoke(WriteFileBinaryContentMethodName, fileBinaryContentVar).Terminate(),
+                        Return()
+                    });
+                cases.Add(fileBinaryContentCase);
+            }
+
+            cases.Add(defaultCase);
+
+            var body = new SwitchStatement(value, cases);
+
+            return new MethodProvider(signature, body, this, XmlDocProvider.Empty);
+        }
+
+        private MethodProvider BuildWriteFileBinaryContentXmlMethodProvider()
+        {
+            var valueParameter = new ParameterProvider("value", FormattableStringHelpers.Empty, typeof(FileBinaryContent));
+            var signature = new MethodSignature(
+                Name: WriteFileBinaryContentMethodName,
+                Description: null,
+                Modifiers: _methodModifiers,
+                ReturnType: null,
+                ReturnDescription: null,
+                Parameters: [_xmlWriterParameter, valueParameter]);
+
+            var writer = _xmlWriterParameter.As<XmlWriter>();
+            var value = valueParameter.As<FileBinaryContent>();
+
+            // value.TryComputeLength(out long length)
+            var tryComputeLength = value.TryComputeLength(out var lengthVariable);
+            var length = lengthVariable.As<long>();
+
+            // length <= int.MaxValue
+            var fitsInInt = new BinaryOperatorExpression("<=", length, IntSnippets.MaxValue).As<bool>();
+
+            // value.TryComputeLength(out long length) && length <= int.MaxValue ? (int)length : 0
+            var capacityExpression = new TernaryConditionalExpression(
+                tryComputeLength.And(fitsInInt),
+                length.CastTo(typeof(int)),
+                Literal(0));
+
+            var declareCapacity = Declare("capacity", typeof(int), capacityExpression, out var capacity);
+
+            // using MemoryStream stream = new MemoryStream(capacity);
+            var declareStream = UsingDeclare(
+                "stream",
+                typeof(MemoryStream),
+                New.Instance<MemoryStream>(capacity),
+                out var stream);
+            var streamScoped = stream.As<Stream>();
+
+            // value.WriteTo(stream);
+            var writeTo = value.WriteTo(streamScoped).Terminate();
+
+            // writer.WriteBase64(stream.GetBuffer(), 0, (int)stream.Position);
+            var positionAsInt = streamScoped.Position().CastTo(typeof(int));
+            var writeBase64 = writer.WriteBase64(streamScoped.GetBuffer(), Literal(0), positionAsInt);
+
+            var body = new MethodBodyStatement[]
+            {
+                declareCapacity,
+                declareStream,
+                writeTo,
+                writeBase64,
+            };
 
             return new MethodProvider(signature, body, this, XmlDocProvider.Empty);
         }