Add support for send file upload API

Src/Notion.Client/Api/ApiEndpoints.cs

@@ -143,6 +143,7 @@ public static class AuthenticationUrls
         public static class FileUploadsApiUrls
         {
             public static string Create() => "/v1/file_uploads";
+            public static string Send(string fileUploadId) => $"/v1/file_uploads/{fileUploadId}/send";
         }
     }
 }

Src/Notion.Client/Api/FileUploads/IFileUploadsClient.cs

@@ -15,5 +15,19 @@ Task<CreateFileUploadResponse> CreateAsync(
             CreateFileUploadRequest fileUploadObjectRequest,
             CancellationToken cancellationToken = default
         );
+
+        /// <summary>
+        /// Send a file upload
+        /// 
+        /// Requires a `file_upload_id`, obtained from the `id` of the Create File Upload API response.
+        /// 
+        /// </summary>
+        /// <param name="sendFileUploadRequest"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task<SendFileUploadResponse> SendAsync(
+            SendFileUploadRequest sendFileUploadRequest,
+            CancellationToken cancellationToken = default
+        );
     }
 }

Src/Notion.Client/Api/FileUploads/Send/FileUploadsClient.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Notion.Client
+{
+    public sealed partial class FileUploadsClient
+    {
+        public async Task<SendFileUploadResponse> SendAsync(
+            SendFileUploadRequest sendFileUploadRequest,
+            CancellationToken cancellationToken = default)
+        {
+            if (sendFileUploadRequest == null)
+            {
+                throw new ArgumentNullException(nameof(sendFileUploadRequest));
+            }
+
+            if (string.IsNullOrEmpty(sendFileUploadRequest.FileUploadId))
+            {
+                throw new ArgumentNullException(nameof(sendFileUploadRequest.FileUploadId));
+            }
+
+            if (sendFileUploadRequest.PartNumber != null)
+            {
+                if (!int.TryParse(sendFileUploadRequest.PartNumber, out int partNumberValue) || partNumberValue < 1 || partNumberValue > 1000)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(sendFileUploadRequest.PartNumber), "PartNumber must be between 1 and 1000.");
+                }
+            }
+
+            var path = ApiEndpoints.FileUploadsApiUrls.Send(sendFileUploadRequest.FileUploadId);
+
+            return await _restClient.PostAsync<SendFileUploadResponse>(
+                path,
+                formData: sendFileUploadRequest,
+                cancellationToken: cancellationToken
+            );
+        }
+    }
+}

Src/Notion.Client/Api/FileUploads/Send/Request/FileData.cs

@@ -0,0 +1,22 @@
+using System.IO;
+
+namespace Notion.Client
+{
+    public class FileData
+    {
+        /// <summary>
+        /// The name of the file being uploaded.
+        /// </summary>
+        public string FileName { get; set; }
+
+        /// <summary>
+        /// The content of the file being uploaded.
+        /// </summary>
+        public Stream Data { get; set; }
+
+        /// <summary>
+        /// The MIME type of the file being uploaded.
+        /// </summary>
+        public string ContentType { get; set; }
+    }
+}

Src/Notion.Client/Api/FileUploads/Send/Request/ISendFileUploadFormDataParameters.cs

@@ -0,0 +1,19 @@
+using Newtonsoft.Json;
+
+namespace Notion.Client
+{
+    public interface ISendFileUploadFormDataParameters
+    {
+        /// <summary>
+        /// The raw binary file contents to upload.
+        /// </summary>
+        FileData File { get; }
+
+        /// <summary>
+        /// When using a mode=multi_part File Upload to send files greater than 20 MB in parts, this is the current part number. 
+        /// Must be an integer between 1 and 1000 provided as a string form field.
+        /// </summary>
+        [JsonProperty("part_number")]
+        string PartNumber { get; }
+    }
+}

Src/Notion.Client/Api/FileUploads/Send/Request/ISendFileUploadPathParameters.cs

@@ -0,0 +1,10 @@
+namespace Notion.Client
+{
+    public interface ISendFileUploadPathParameters
+    {
+        /// <summary>
+        /// The `file_upload_id` obtained from the `id` of the Create File Upload API response.
+        /// </summary>
+        string FileUploadId { get; }
+    }
+}

Src/Notion.Client/Api/FileUploads/Send/Request/SendFileUploadRequest.cs

@@ -0,0 +1,21 @@
+namespace Notion.Client
+{
+    public class SendFileUploadRequest : ISendFileUploadFormDataParameters, ISendFileUploadPathParameters
+    {
+        public FileData File { get; private set; }
+        public string PartNumber { get; private set; }
+        public string FileUploadId { get; private set; }
+
+        private SendFileUploadRequest() { }
+
+        public static SendFileUploadRequest Create(string fileUploadId, FileData file, string partNumber = null)
+        {
+            return new SendFileUploadRequest
+            {
+                FileUploadId = fileUploadId,
+                File = file,
+                PartNumber = partNumber
+            };
+        }
+    }
+}

Src/Notion.Client/Api/FileUploads/Send/Response/SendFileUploadResponse.cs

@@ -0,0 +1,6 @@
+namespace Notion.Client
+{
+    public class SendFileUploadResponse : FileObjectResponse
+    {
+    }
+}

Src/Notion.Client/RestClient/IRestClient.cs

@@ -23,6 +23,15 @@ Task<T> PostAsync<T>(
             IBasicAuthenticationParameters basicAuthenticationParameters = null,
             CancellationToken cancellationToken = default);
 
+        Task<T> PostAsync<T>(
+            string uri,
+            ISendFileUploadFormDataParameters formData,
+            IEnumerable<KeyValuePair<string, string>> queryParams = null,
+            IDictionary<string, string> headers = null,
+            JsonSerializerSettings serializerSettings = null,
+            IBasicAuthenticationParameters basicAuthenticationParameters = null,
+            CancellationToken cancellationToken = default);
+
         Task<T> PatchAsync<T>(
             string uri,
             object body,

Src/Notion.Client/RestClient/RestClient.cs

@@ -70,6 +70,46 @@ void AttachContent(HttpRequestMessage httpRequest)
             return await response.ParseStreamAsync<T>(serializerSettings);
         }
 
+        public async Task<T> PostAsync<T>(
+            string uri,
+            ISendFileUploadFormDataParameters formData,
+            IEnumerable<KeyValuePair<string, string>> queryParams = null,
+            IDictionary<string, string> headers = null,
+            JsonSerializerSettings serializerSettings = null,
+            IBasicAuthenticationParameters basicAuthenticationParameters = null,
+            CancellationToken cancellationToken = default)
+        {
+            void AttachContent(HttpRequestMessage httpRequest)
+            {
+                var fileContent = new StreamContent(formData.File.Data);
+                fileContent.Headers.ContentType = new MediaTypeHeaderValue(formData.File.ContentType);
+
+                var form = new MultipartFormDataContent
+                {
+                    { fileContent, "file", formData.File.FileName }
+                };
+
+                if (!string.IsNullOrEmpty(formData.PartNumber))
+                {
+                    form.Add(new StringContent(formData.PartNumber), "part_number");
+                }
+
+                httpRequest.Content = form;
+            }
+
+            var response = await SendAsync(
+                uri,
+                HttpMethod.Post,
+                queryParams,
+                headers,
+                AttachContent,
+                basicAuthenticationParameters,
+                cancellationToken
+            );
+
+            return await response.ParseStreamAsync<T>(serializerSettings);
+        }
+
         public async Task<T> PatchAsync<T>(
             string uri,
             object body,

Test/Notion.IntegrationTests/FIleUploadsClientTests.cs

@@ -25,5 +25,37 @@ public async Task CreateAsync()
             Assert.NotNull(response.Status);
             Assert.Equal("sample-image.jpg", response.FileName);
         }
+
+        [Fact]
+        public async Task Verify_file_upload_flow()
+        {
+            // Arrange
+            var createRequest = new CreateFileUploadRequest
+            {
+                Mode = FileUploadMode.SinglePart,
+                FileName = "notion-logo.png",
+            };
+
+            var createResponse = await Client.FileUploads.CreateAsync(createRequest);
+
+            var sendRequest = SendFileUploadRequest.Create(
+                createResponse.Id,
+                new FileData
+                {
+                    FileName = "notion-logo.png",
+                    Data = System.IO.File.OpenRead("assets/notion-logo.png"),
+                    ContentType = createResponse.ContentType
+                }
+            );
+
+            // Act
+            var sendResponse = await Client.FileUploads.SendAsync(sendRequest);
+
+            // Assert
+            Assert.NotNull(sendResponse);
+            Assert.Equal(createResponse.Id, sendResponse.Id);
+            Assert.Equal("notion-logo.png", sendResponse.FileName);
+            Assert.Equal("uploaded", sendResponse.Status);
+        }
     }
 }

Test/Notion.IntegrationTests/Notion.IntegrationTests.csproj

@@ -11,6 +11,12 @@
     <ProjectReference Include="..\..\Src\Notion.Client\Notion.Client.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Content Include="assets\notion-logo.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="FluentAssertions" Version="5.10.3" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.4" />

Test/Notion.UnitTests/FileUploadClientTests.cs

@@ -67,4 +67,115 @@ public async Task CreateAsync_CallsRestClientPostAsync_WithCorrectParameters()
 
         _restClientMock.VerifyAll();
     }
-}
+
+    [Fact]
+    public async Task SendAsync_ThrowsArgumentNullException_WhenRequestIsNull()
+    {
+        // Act & Assert
+        var exception = await Assert.ThrowsAsync<ArgumentNullException>(() => _fileUploadClient.SendAsync(null));
+        Assert.Equal("sendFileUploadRequest", exception.ParamName);
+        Assert.Equal("Value cannot be null. (Parameter 'sendFileUploadRequest')", exception.Message);
+    }
+
+    [Fact]
+    public async Task SendAsync_ThrowsArgumentNullException_WhenFileUploadIdIsNullOrEmpty()
+    {
+        // Arrange
+        var request = SendFileUploadRequest.Create(fileUploadId: null, file: new FileData { FileName = "testfile.txt", Data = new System.IO.MemoryStream(), ContentType = "text/plain" });
+
+        // Act & Assert
+        var exception = await Assert.ThrowsAsync<ArgumentNullException>(() => _fileUploadClient.SendAsync(request));
+        Assert.Equal("FileUploadId", exception.ParamName);
+        Assert.Equal("Value cannot be null. (Parameter 'FileUploadId')", exception.Message);
+    }
+
+    [Theory]
+    [InlineData("0")]
+    [InlineData("1001")]
+    [InlineData("-5")]
+    [InlineData("abc")]
+    public async Task SendAsync_ThrowsArgumentOutOfRangeException_WhenPartNumberIsInvalid(string partNumber)
+    {
+        // Arrange
+        var request = SendFileUploadRequest.Create(fileUploadId: "valid-id", file: new FileData { FileName = "testfile.txt", Data = new System.IO.MemoryStream(), ContentType = "text/plain" }, partNumber: partNumber);
+
+        // Act & Assert
+        var exception = await Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => _fileUploadClient.SendAsync(request));
+        Assert.Equal("PartNumber", exception.ParamName);
+        Assert.Contains("PartNumber must be between 1 and 1000.", exception.Message);
+    }
+
+    [Theory]
+    [InlineData("1")]
+    [InlineData("500")]
+    [InlineData("1000")]
+    public async Task SendAsync_DoesNotThrow_WhenPartNumberIsValid(string partNumber)
+    {
+        // Arrange
+        var request = SendFileUploadRequest.Create(fileUploadId: "valid-id", file: new FileData { FileName = "testfile.txt", Data = new System.IO.MemoryStream(), ContentType = "text/plain" }, partNumber: partNumber);
+
+        var expectedResponse = new SendFileUploadResponse
+        {
+            Id = "valid-id",
+            Status = "uploaded",
+        };
+
+        _restClientMock
+            .Setup(client => client.PostAsync<SendFileUploadResponse>(
+                It.Is<string>(url => url == ApiEndpoints.FileUploadsApiUrls.Send("valid-id")),
+                It.IsAny<ISendFileUploadFormDataParameters>(),
+                It.IsAny<IEnumerable<KeyValuePair<string, string>>>(),
+                It.IsAny<IDictionary<string, string>>(),
+                It.IsAny<JsonSerializerSettings>(),
+                It.IsAny<IBasicAuthenticationParameters>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(expectedResponse);
+
+        // Act
+        var exception = await Record.ExceptionAsync(() => _fileUploadClient.SendAsync(request));
+
+        // Assert
+        Assert.Null(exception);
+        _restClientMock.VerifyAll();
+    }
+
+    [Fact]
+    public async Task SendAsync_CallsRestClientPostAsync_WithCorrectParameters()
+    {
+        // Arrange
+        var fileUploadId = Guid.NewGuid().ToString();
+        var request = SendFileUploadRequest.Create(
+            fileUploadId: fileUploadId,
+            file: new FileData
+            {
+                FileName = "testfile.txt",
+                Data = new System.IO.MemoryStream(),
+                ContentType = "text/plain"
+            }
+        );
+
+        var expectedResponse = new SendFileUploadResponse
+        {
+            Id = fileUploadId.ToString(),
+            Status = "uploaded",
+        };
+
+        _restClientMock
+            .Setup(client => client.PostAsync<SendFileUploadResponse>(
+                It.Is<string>(url => url == ApiEndpoints.FileUploadsApiUrls.Send(fileUploadId)),
+                It.IsAny<ISendFileUploadFormDataParameters>(),
+                It.IsAny<IEnumerable<KeyValuePair<string, string>>>(),
+                It.IsAny<IDictionary<string, string>>(),
+                It.IsAny<JsonSerializerSettings>(),
+                It.IsAny<IBasicAuthenticationParameters>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(expectedResponse);
+        // Act
+        var response = await _fileUploadClient.SendAsync(request);
+
+        // Assert
+        Assert.Equal(expectedResponse.Status, response.Status);
+        Assert.Equal(expectedResponse.Id, response.Id);
+        _restClientMock.VerifyAll();
+    }
+}