Is it possible to generate a model for multipart requests?

[AndrewL97]

I have an endpoint that requires some properties, one of which is IFormFile.

i.e

public class MyRequest
{
    public Guid? Id { get; set; }

    public string someString { get; set; }

    public List<MyChildObject> childObjects { get; set; }

    public IFormFile myFile { get; set; }

Without the IFormFile, Kiota generates a request model with properties and their respective type. (I believe asp.net/swaggergen defaults to application/x-www-form-urlencoded).

However, once we change to multipart/form-data, Kiota exposes the relevent endpoints with a MultipartBody, and so we lose the schema.

Is there a way to expose the request model instead of MultiPartBody (with IFormFile support), via config, correct swaggergen attributes, etc?

I have looked at this ->
#3826 , which has the issue I am trying to avoid (AddOrReplacePart for each property)
and microsoft/kiota-dotnet#212 for the AddOrReplacePart with the new filename parameter

The biggest issue we have at the moment is the complexity of handling our childObjects list in MultiPartBody - without manually referring back to the swagger file, it is impossible to setup our request (unless I am just missing something, I am very sleepy :) )

[baywet]

Hi @AndrewL97
Thanks for using kiota and for reaching out.
Can you share the description for the operation with and without the file please?

[AndrewL97]

Hey @baywet !

Thanks for the quick response, and apologies for my sleep-deprived rambling :)

This is a test controller I have made

/NoFile uses MessageWithAttachments Contains some properties and an array of objects (without any IFormFile)
/WithFile uses MessageWithFileAttachments has identical models to the above, but with IFormFile added to FileAttachment
/WithFileFromForm/ uses MessageWithFileAttachments, but uses [FromForm] (which seems to force Kiota to use MultiPartBody)

         [HttpPost("NoFile")]
        [Consumes("multipart/form-data")]
        public IActionResult NoFile(MessageWithAttachments message)
        {
            return new OkResult();
        }

        [HttpPost("WithFile")]
        [Consumes("multipart/form-data")]
        public IActionResult WithFile(MessageWithFileAttachments message)
        {
            return new OkResult();
        }

        [HttpPost("WithFileFromForm")]
        [Consumes("multipart/form-data")]
        public IActionResult WithFileFromForm([FromForm] MessageWithFileAttachments message)
        {
            return new OkResult();
        }

The MessageWithAttachments model is this:

    public class MessageWithFileAttachments
    {
        public string Subject { get; set; }
        public string Body { get; set; }
        public List<FileAttachment> Attachments { get; set; }
    }

And then FileAttachment looks like this

    public class FileAttachment
    {
        public string Description { get; set; }
        public DateTime ExpiryDate { get; set; }
        public IFormFile File { get; set; }
    }

(MessageWithAttachments and Attachments are the same as the above, just without IFormFile)

This spits out this swagger.json

{
    "openapi": "3.0.1",
    "info": {
        "title": "FormFileTest",
        "version": "1.0"
    },
    "paths": {
        "/Message/NoFile": {
            "post": {
                "tags": [
                    "Message"
                ],
                "requestBody": {
                    "content": {
                        "multipart/form-data": {
                            "schema": {
                                "$ref": "#/components/schemas/MessageWithAttachments"
                            }
                        }
                    }
                },
                "responses": {
                    "200": {
                        "description": "Success"
                    }
                }
            }
        },
        "/Message/WithFile": {
            "post": {
                "tags": [
                    "Message"
                ],
                "requestBody": {
                    "content": {
                        "multipart/form-data": {
                            "schema": {
                                "$ref": "#/components/schemas/MessageWithFileAttachments"
                            }
                        }
                    }
                },
                "responses": {
                    "200": {
                        "description": "Success"
                    }
                }
            }
        },
        "/Message/WithFileFromForm": {
            "post": {
                "tags": [
                    "Message"
                ],
                "requestBody": {
                    "content": {
                        "multipart/form-data": {
                            "schema": {
                                "type": "object",
                                "properties": {
                                    "Subject": {
                                        "type": "string"
                                    },
                                    "Body": {
                                        "type": "string"
                                    },
                                    "Attachments": {
                                        "type": "array",
                                        "items": {
                                            "$ref": "#/components/schemas/FileAttachment"
                                        }
                                    }
                                }
                            },
                            "encoding": {
                                "Subject": {
                                    "style": "form"
                                },
                                "Body": {
                                    "style": "form"
                                },
                                "Attachments": {
                                    "style": "form"
                                }
                            }
                        }
                    }
                },
                "responses": {
                    "200": {
                        "description": "Success"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "Attachment": {
                "type": "object",
                "properties": {
                    "description": {
                        "type": "string",
                        "nullable": true
                    },
                    "expiryDate": {
                        "type": "string",
                        "format": "date-time"
                    }
                },
                "additionalProperties": false
            },
            "FileAttachment": {
                "type": "object",
                "properties": {
                    "description": {
                        "type": "string",
                        "nullable": true
                    },
                    "expiryDate": {
                        "type": "string",
                        "format": "date-time"
                    },
                    "file": {
                        "type": "string",
                        "format": "binary",
                        "nullable": true
                    }
                },
                "additionalProperties": false
            },
            "MessageWithAttachments": {
                "type": "object",
                "properties": {
                    "subject": {
                        "type": "string",
                        "nullable": true
                    },
                    "body": {
                        "type": "string",
                        "nullable": true
                    },
                    "attachments": {
                        "type": "array",
                        "items": {
                            "$ref": "#/components/schemas/Attachment"
                        },
                        "nullable": true
                    }
                },
                "additionalProperties": false
            },
            "MessageWithFileAttachments": {
                "type": "object",
                "properties": {
                    "subject": {
                        "type": "string",
                        "nullable": true
                    },
                    "body": {
                        "type": "string",
                        "nullable": true
                    },
                    "attachments": {
                        "type": "array",
                        "items": {
                            "$ref": "#/components/schemas/FileAttachment"
                        },
                        "nullable": true
                    }
                },
                "additionalProperties": false
            }
        }
    }
}

Generating the kiota client with the vscode extension creates models for /NoFile and /WithFile, however /WithFileFromForm only accepts MultiPartBody, which doesn't expose the available properties - however we only MultiPartBody lets us add a File, as /WithFile treats the File property as a string.

Please let me know if you need any extra info :)

[baywet]

Thanks for sharing this. I'm not sure why the FromForm attribute results in the description splitting the schema here. IMHO it should be identical to the description of WithFile endpoint. Maybe worth having @captainsafia take a look at that.

As for your initial question, using the multipart body object, you should be able to add parsable body parts with the add or replace part method. (i.e. just add your model value with application/json as the media type and the property name (casing needs to match) as the part name)

[MMAndrewL]

Hey @baywet - the bit that I was hoping to avoid was this :)

you should be able to add parsable body parts with the add or replace part method. (i.e. just add your model value with application/json as the media type and the property name (casing needs to match) as the part name)

Was hoping that there was a way to expose the original request model as a MultiPartBody, but with properties defined against it. With the base MultiPartBody, any third parties using the generated Kiota client will also need to refer to the swagger.json.

I ended up re-defining the request models on the client implementation side, with a "ToMultipartBody" extension method that looped over GetProperties, and threw everything into AddOrReplacePart

[baywet]

The reason why kiota can't generate a model for the multipart body itself is because the serialization infrastructure (serialization writer interface really) does not have parameters for the media type of each part. And adding those would be source breaking. We did the best we could in terms of developer experience while avoiding breaking people and landed on this compromise.
Glad you worked out a more ergonomic solution!

[StefH]

Just some details on how I solved it for my projects:

API

A .NET 9 API Controller expects a [FromForm] IFormFileCollection files:

[HttpPost("Decode")]
[Consumes(MediaTypeNames.Multipart.FormData)]
[RequestSizeLimit(ValidationRanges.ReceiptFileMaximumSizeInBytes)]
[ProducesResponseType<IReadOnlyList<NewExpensesClaimLineData>>(StatusCodes.Status200OK)]
[ProducesResponseType<ProblemDetails>(StatusCodes.Status400BadRequest)]
public async Task<IResult> Decode([FromForm] IFormFileCollection files, [FromQuery] bool includeContentInResponse = true)
{
}

Client

The generated client code had this method signature:

public async Task<List<NewExpensesClaimLineData>?> PostAsync(
    DecodePostRequestBody body,
    Action<RequestConfiguration<DecodeRequestBuilder.DecodeRequestBuilderPostQueryParameters>>? requestConfiguration = default,
    CancellationToken cancellationToken = default)

I could not use this PostAsync method for MultipartFormDataContent. So I added my own code in another partial DecodeRequestBuilder class.

Extra method

public async Task<List<NewExpensesClaimLineData>?> PostAsync(
    MultipartFormDataContent multipartContent,
    Action<RequestConfiguration<DecodeRequestBuilderPostQueryParameters>>? requestConfiguration = default,
    CancellationToken cancellationToken = default)
{
     // ✨ Just add some extra validation
    ArgumentNullException.ThrowIfNull(multipartContent);
    ArgumentNullException.ThrowIfNull(multipartContent.Headers.ContentType);

    // ✨ Add the same errorMapping as defined in the original generated method
    var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
    {
        { "400", ProblemDetails.CreateFromDiscriminatorValue },
        { "401", ProblemDetails.CreateFromDiscriminatorValue }
    };

    // ✨Create a requestInfo object and make sure to configure it correctly.
    var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
    requestInfo.Configure(requestConfiguration);

    // ✨Get the Stream + ContentType from the multipartContent and set it to the requestInfo
    requestInfo.SetStreamContent(await multipartContent.ReadAsStreamAsync(cancellationToken), multipartContent.Headers.ContentType.ToString());

    // ✨Now just call the same code as was generated
    var collectionResult = await RequestAdapter.SendCollectionAsync(requestInfo, NewExpensesClaimLineData.CreateFromDiscriminatorValue, errorMapping, cancellationToken);
    return collectionResult?.AsList();
}