Release 0.6.0

Author: fern-api[bot]

.editorconfig

@@ -0,0 +1,35 @@
+root = true
+
+[*.cs]
+resharper_arrange_object_creation_when_type_evident_highlighting = hint
+resharper_auto_property_can_be_made_get_only_global_highlighting = hint
+resharper_check_namespace_highlighting = hint
+resharper_class_never_instantiated_global_highlighting = hint
+resharper_class_never_instantiated_local_highlighting = hint
+resharper_collection_never_updated_global_highlighting = hint
+resharper_convert_type_check_pattern_to_null_check_highlighting = hint
+resharper_inconsistent_naming_highlighting = hint
+resharper_member_can_be_private_global_highlighting = hint
+resharper_member_hides_static_from_outer_class_highlighting = hint
+resharper_not_accessed_field_local_highlighting = hint
+resharper_nullable_warning_suppression_is_used_highlighting = suggestion
+resharper_partial_type_with_single_part_highlighting = hint
+resharper_prefer_concrete_value_over_default_highlighting = none
+resharper_private_field_can_be_converted_to_local_variable_highlighting = hint
+resharper_property_can_be_made_init_only_global_highlighting = hint
+resharper_property_can_be_made_init_only_local_highlighting = hint
+resharper_redundant_name_qualifier_highlighting = none
+resharper_redundant_using_directive_highlighting = hint
+resharper_replace_slice_with_range_indexer_highlighting = none
+resharper_unused_auto_property_accessor_global_highlighting = hint
+resharper_unused_auto_property_accessor_local_highlighting = hint
+resharper_unused_member_global_highlighting = hint
+resharper_unused_type_global_highlighting = hint
+resharper_use_string_interpolation_highlighting = hint
+dotnet_diagnostic.CS1591.severity = suggestion
+
+[src/**/Types/*.cs]
+resharper_check_namespace_highlighting = none
+
+[src/**/Core/Public/*.cs]
+resharper_check_namespace_highlighting = none

src/Vapi.Net.Test/Core/Json/DateOnlyJsonTests.cs

@@ -0,0 +1,76 @@
+using NUnit.Framework;
+using Vapi.Net.Core;
+
+namespace Vapi.Net.Test.Core.Json;
+
+[TestFixture]
+public class DateOnlyJsonTests
+{
+    [Test]
+    public void SerializeDateOnly_ShouldMatchExpectedFormat()
+    {
+        (DateOnly dateOnly, string expected)[] testCases =
+        [
+            (new DateOnly(2023, 10, 5), "\"2023-10-05\""),
+            (new DateOnly(2023, 1, 1), "\"2023-01-01\""),
+            (new DateOnly(2023, 12, 31), "\"2023-12-31\""),
+            (new DateOnly(2023, 6, 15), "\"2023-06-15\""),
+            (new DateOnly(2023, 3, 10), "\"2023-03-10\""),
+        ];
+        foreach (var (dateOnly, expected) in testCases)
+        {
+            var json = JsonUtils.Serialize(dateOnly);
+            Assert.That(json, Is.EqualTo(expected));
+        }
+    }
+
+    [Test]
+    public void DeserializeDateOnly_ShouldMatchExpectedDateOnly()
+    {
+        (DateOnly expected, string json)[] testCases =
+        [
+            (new DateOnly(2023, 10, 5), "\"2023-10-05\""),
+            (new DateOnly(2023, 1, 1), "\"2023-01-01\""),
+            (new DateOnly(2023, 12, 31), "\"2023-12-31\""),
+            (new DateOnly(2023, 6, 15), "\"2023-06-15\""),
+            (new DateOnly(2023, 3, 10), "\"2023-03-10\""),
+        ];
+
+        foreach (var (expected, json) in testCases)
+        {
+            var dateOnly = JsonUtils.Deserialize<DateOnly>(json);
+            Assert.That(dateOnly, Is.EqualTo(expected));
+        }
+    }
+
+    [Test]
+    public void SerializeNullableDateOnly_ShouldMatchExpectedFormat()
+    {
+        (DateOnly? dateOnly, string expected)[] testCases =
+        [
+            (new DateOnly(2023, 10, 5), "\"2023-10-05\""),
+            (null, "null"),
+        ];
+        foreach (var (dateOnly, expected) in testCases)
+        {
+            var json = JsonUtils.Serialize(dateOnly);
+            Assert.That(json, Is.EqualTo(expected));
+        }
+    }
+
+    [Test]
+    public void DeserializeNullableDateOnly_ShouldMatchExpectedDateOnly()
+    {
+        (DateOnly? expected, string json)[] testCases =
+        [
+            (new DateOnly(2023, 10, 5), "\"2023-10-05\""),
+            (null, "null"),
+        ];
+
+        foreach (var (expected, json) in testCases)
+        {
+            var dateOnly = JsonUtils.Deserialize<DateOnly?>(json);
+            Assert.That(dateOnly, Is.EqualTo(expected));
+        }
+    }
+}

src/Vapi.Net.Test/Core/Json/DateTimeJsonTests.cs

@@ -0,0 +1,110 @@
+using NUnit.Framework;
+using Vapi.Net.Core;
+
+namespace Vapi.Net.Test.Core.Json;
+
+[TestFixture]
+public class DateTimeJsonTests
+{
+    [Test]
+    public void SerializeDateTime_ShouldMatchExpectedFormat()
+    {
+        (DateTime dateTime, string expected)[] testCases =
+        [
+            (
+                new DateTime(2023, 10, 5, 14, 30, 0, DateTimeKind.Utc),
+                "\"2023-10-05T14:30:00.000Z\""
+            ),
+            (new DateTime(2023, 1, 1, 0, 0, 0, DateTimeKind.Utc), "\"2023-01-01T00:00:00.000Z\""),
+            (
+                new DateTime(2023, 12, 31, 23, 59, 59, DateTimeKind.Utc),
+                "\"2023-12-31T23:59:59.000Z\""
+            ),
+            (new DateTime(2023, 6, 15, 12, 0, 0, DateTimeKind.Utc), "\"2023-06-15T12:00:00.000Z\""),
+            (
+                new DateTime(2023, 3, 10, 8, 45, 30, DateTimeKind.Utc),
+                "\"2023-03-10T08:45:30.000Z\""
+            ),
+            (
+                new DateTime(2023, 3, 10, 8, 45, 30, 123, DateTimeKind.Utc),
+                "\"2023-03-10T08:45:30.123Z\""
+            ),
+        ];
+        foreach (var (dateTime, expected) in testCases)
+        {
+            var json = JsonUtils.Serialize(dateTime);
+            Assert.That(json, Is.EqualTo(expected));
+        }
+    }
+
+    [Test]
+    public void DeserializeDateTime_ShouldMatchExpectedDateTime()
+    {
+        (DateTime expected, string json)[] testCases =
+        [
+            (
+                new DateTime(2023, 10, 5, 14, 30, 0, DateTimeKind.Utc),
+                "\"2023-10-05T14:30:00.000Z\""
+            ),
+            (new DateTime(2023, 1, 1, 0, 0, 0, DateTimeKind.Utc), "\"2023-01-01T00:00:00.000Z\""),
+            (
+                new DateTime(2023, 12, 31, 23, 59, 59, DateTimeKind.Utc),
+                "\"2023-12-31T23:59:59.000Z\""
+            ),
+            (new DateTime(2023, 6, 15, 12, 0, 0, DateTimeKind.Utc), "\"2023-06-15T12:00:00.000Z\""),
+            (
+                new DateTime(2023, 3, 10, 8, 45, 30, DateTimeKind.Utc),
+                "\"2023-03-10T08:45:30.000Z\""
+            ),
+            (new DateTime(2023, 3, 10, 8, 45, 30, DateTimeKind.Utc), "\"2023-03-10T08:45:30Z\""),
+            (
+                new DateTime(2023, 3, 10, 8, 45, 30, 123, DateTimeKind.Utc),
+                "\"2023-03-10T08:45:30.123Z\""
+            ),
+        ];
+
+        foreach (var (expected, json) in testCases)
+        {
+            var dateTime = JsonUtils.Deserialize<DateTime>(json);
+            Assert.That(dateTime, Is.EqualTo(expected));
+        }
+    }
+
+    [Test]
+    public void SerializeNullableDateTime_ShouldMatchExpectedFormat()
+    {
+        (DateTime? expected, string json)[] testCases =
+        [
+            (
+                new DateTime(2023, 10, 5, 14, 30, 0, DateTimeKind.Utc),
+                "\"2023-10-05T14:30:00.000Z\""
+            ),
+            (null, "null"),
+        ];
+
+        foreach (var (expected, json) in testCases)
+        {
+            var dateTime = JsonUtils.Deserialize<DateTime?>(json);
+            Assert.That(dateTime, Is.EqualTo(expected));
+        }
+    }
+
+    [Test]
+    public void DeserializeNullableDateTime_ShouldMatchExpectedDateTime()
+    {
+        (DateTime? expected, string json)[] testCases =
+        [
+            (
+                new DateTime(2023, 10, 5, 14, 30, 0, DateTimeKind.Utc),
+                "\"2023-10-05T14:30:00.000Z\""
+            ),
+            (null, "null"),
+        ];
+
+        foreach (var (expected, json) in testCases)
+        {
+            var dateTime = JsonUtils.Deserialize<DateTime?>(json);
+            Assert.That(dateTime, Is.EqualTo(expected));
+        }
+    }
+}

src/Vapi.Net.Test/Core/EnumSerializerTests.cs renamed to src/Vapi.Net.Test/Core/Json/EnumSerializerTests.cs

@@ -4,7 +4,7 @@
 using NUnit.Framework;
 using Vapi.Net.Core;
 
-namespace Vapi.Net.Test.Core;
+namespace Vapi.Net.Test.Core.Json;
 
 [TestFixture]
 [Parallelizable(ParallelScope.All)]

src/Vapi.Net.Test/Core/Json/JsonAccessAttributeTests.cs

@@ -0,0 +1,160 @@
+using global::System.Text.Json.Serialization;
+using NUnit.Framework;
+using Vapi.Net.Core;
+
+namespace Vapi.Net.Test.Core.Json;
+
+[TestFixture]
+public class JsonAccessAttributeTests
+{
+    private class MyClass
+    {
+        [JsonPropertyName("read_only_prop")]
+        [JsonAccess(JsonAccessType.ReadOnly)]
+        public string? ReadOnlyProp { get; set; }
+
+        [JsonPropertyName("write_only_prop")]
+        [JsonAccess(JsonAccessType.WriteOnly)]
+        public string? WriteOnlyProp { get; set; }
+
+        [JsonPropertyName("normal_prop")]
+        public string? NormalProp { get; set; }
+
+        [JsonPropertyName("read_only_nullable_list")]
+        [JsonAccess(JsonAccessType.ReadOnly)]
+        public IEnumerable<string>? ReadOnlyNullableList { get; set; }
+
+        [JsonPropertyName("read_only_list")]
+        [JsonAccess(JsonAccessType.ReadOnly)]
+        public IEnumerable<string> ReadOnlyList { get; set; } = [];
+
+        [JsonPropertyName("write_only_nullable_list")]
+        [JsonAccess(JsonAccessType.WriteOnly)]
+        public IEnumerable<string>? WriteOnlyNullableList { get; set; }
+
+        [JsonPropertyName("write_only_list")]
+        [JsonAccess(JsonAccessType.WriteOnly)]
+        public IEnumerable<string> WriteOnlyList { get; set; } = [];
+
+        [JsonPropertyName("normal_list")]
+        public IEnumerable<string> NormalList { get; set; } = [];
+
+        [JsonPropertyName("normal_nullable_list")]
+        public IEnumerable<string>? NullableNormalList { get; set; }
+    }
+
+    [Test]
+    public void JsonAccessAttribute_ShouldWorkAsExpected()
+    {
+        const string json = """
+            {
+                "read_only_prop": "read",
+                "write_only_prop": "write",
+                "normal_prop": "normal_prop",
+                "read_only_nullable_list": ["item1", "item2"],
+                "read_only_list": ["item3", "item4"],
+                "write_only_nullable_list": ["item5", "item6"],
+                "write_only_list": ["item7", "item8"],
+                "normal_list": ["normal1", "normal2"],
+                "normal_nullable_list": ["normal1", "normal2"]
+            }
+            """;
+        var obj = JsonUtils.Deserialize<MyClass>(json);
+
+        Assert.Multiple(() =>
+        {
+            // String properties
+            Assert.That(obj.ReadOnlyProp, Is.EqualTo("read"));
+            Assert.That(obj.WriteOnlyProp, Is.Null);
+            Assert.That(obj.NormalProp, Is.EqualTo("normal_prop"));
+
+            // List properties - read only
+            var nullableReadOnlyList = obj.ReadOnlyNullableList?.ToArray();
+            Assert.That(nullableReadOnlyList, Is.Not.Null);
+            Assert.That(nullableReadOnlyList, Has.Length.EqualTo(2));
+            Assert.That(nullableReadOnlyList[0], Is.EqualTo("item1"));
+            Assert.That(nullableReadOnlyList[1], Is.EqualTo("item2"));
+
+            var readOnlyList = obj.ReadOnlyList.ToArray();
+            Assert.That(readOnlyList, Is.Not.Null);
+            Assert.That(readOnlyList, Has.Length.EqualTo(2));
+            Assert.That(readOnlyList[0], Is.EqualTo("item3"));
+            Assert.That(readOnlyList[1], Is.EqualTo("item4"));
+
+            // List properties - write only
+            Assert.That(obj.WriteOnlyNullableList, Is.Null);
+            Assert.That(obj.WriteOnlyList, Is.Not.Null);
+            Assert.That(obj.WriteOnlyList, Is.Empty);
+
+            // Normal list property
+            var normalList = obj.NormalList.ToArray();
+            Assert.That(normalList, Is.Not.Null);
+            Assert.That(normalList, Has.Length.EqualTo(2));
+            Assert.That(normalList[0], Is.EqualTo("normal1"));
+            Assert.That(normalList[1], Is.EqualTo("normal2"));
+        });
+
+        // Set up values for serialization
+        obj.WriteOnlyProp = "write";
+        obj.NormalProp = "new_value";
+        obj.WriteOnlyNullableList = new List<string> { "write1", "write2" };
+        obj.WriteOnlyList = new List<string> { "write3", "write4" };
+        obj.NormalList = new List<string> { "new_normal" };
+        obj.NullableNormalList = new List<string> { "new_normal" };
+
+        var serializedJson = JsonUtils.Serialize(obj);
+        const string expectedJson = """
+            {
+              "write_only_prop": "write",
+              "normal_prop": "new_value",
+              "write_only_nullable_list": [
+                "write1",
+                "write2"
+              ],
+              "write_only_list": [
+                "write3",
+                "write4"
+              ],
+              "normal_list": [
+                "new_normal"
+              ],
+              "normal_nullable_list": [
+                "new_normal"
+              ]
+            }
+            """;
+        Assert.That(serializedJson, Is.EqualTo(expectedJson).IgnoreWhiteSpace);
+    }
+
+    [Test]
+    public void JsonAccessAttribute_WithNullListsInJson_ShouldWorkAsExpected()
+    {
+        const string json = """
+            {
+                "read_only_prop": "read",
+                "normal_prop": "normal_prop",
+                "read_only_nullable_list": null,
+                "read_only_list": []
+            }
+            """;
+        var obj = JsonUtils.Deserialize<MyClass>(json);
+
+        Assert.Multiple(() =>
+        {
+            // Read-only nullable list should be null when JSON contains null
+            var nullableReadOnlyList = obj.ReadOnlyNullableList?.ToArray();
+            Assert.That(nullableReadOnlyList, Is.Null);
+
+            // Read-only non-nullable list should never be null, but empty when JSON contains null
+            var readOnlyList = obj.ReadOnlyList.ToArray(); // This should be initialized to an empty list by default
+            Assert.That(readOnlyList, Is.Not.Null);
+            Assert.That(readOnlyList, Is.Empty);
+        });
+
+        // Serialize and verify read-only lists are not included
+        var serializedJson = JsonUtils.Serialize(obj);
+        Assert.That(serializedJson, Does.Not.Contain("read_only_prop"));
+        Assert.That(serializedJson, Does.Not.Contain("read_only_nullable_list"));
+        Assert.That(serializedJson, Does.Not.Contain("read_only_list"));
+    }
+}