SpatialPoint Serialization/Deserialization: Fixes spatial point serialization/deserialization bug

Microsoft.Azure.Cosmos/src/Spatial/BoundingBox.cs

@@ -7,13 +7,15 @@ namespace Microsoft.Azure.Cosmos.Spatial
     using System;
     using System.Runtime.Serialization;
     using Microsoft.Azure.Cosmos.Spatial.Converters;
+    using Microsoft.Azure.Cosmos.Spatial.Converters.STJConverters;
     using Newtonsoft.Json;
 
     /// <summary>
     /// Represents a coordinate range for geometries in the Azure Cosmos DB service.
     /// </summary>
     [DataContract]
     [JsonConverter(typeof(BoundingBoxJsonConverter))]
+    [System.Text.Json.Serialization.JsonConverter(typeof(BoundingBoxSTJConverter))]
     public sealed class BoundingBox : IEquatable<BoundingBox>
     {
         /// <summary>

Microsoft.Azure.Cosmos/src/Spatial/Converters/CrsJsonConverter.cs

@@ -122,7 +122,7 @@ public override object ReadJson(
                         throw new JsonSerializationException(RMResources.SpatialFailedToDeserializeCrs);
                     }
 
-                    return new LinkedCrs(crsHref.Value<string>(), crsHrefType.Value<string>());
+                    return new LinkedCrs(crsHref.Value<string>(), crsHrefType?.Value<string>());
 
                 default:
                     throw new JsonSerializationException(RMResources.SpatialFailedToDeserializeCrs);

Microsoft.Azure.Cosmos/src/Spatial/Converters/STJConverters/BoundingBoxSTJConverter.cs

@@ -0,0 +1,64 @@
+// ------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+// ------------------------------------------------------------
+
+namespace Microsoft.Azure.Cosmos.Spatial.Converters.STJConverters
+{
+    using System;
+    using System.Globalization;
+    using System.Linq;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using Microsoft.Azure.Documents;
+    /// <summary>
+    /// Converter used to support System.Text.Json serialization/deserialization of BoundingBox.
+    /// </summary>
+    internal sealed class BoundingBoxSTJConverter : JsonConverter<BoundingBox>
+    {
+        /// <summary>
+        /// Deserializes a BoundingBox from a JSON array of coordinates.
+        /// The array contains min coordinates followed by max coordinates.
+        /// Example: [minLon, minLat, maxLon, maxLat] for 2D or [minLon, minLat, minAlt, maxLon, maxLat, maxAlt] for 3D.
+        /// </summary>
+        public override BoundingBox Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            double[] coordinates = JsonSerializer.Deserialize<double[]>(ref reader, options);
+            if (coordinates == null)
+            {
+                return null;
+            }
+
+            if (coordinates.Length % 2 != 0 || coordinates.Length < 4)
+            {
+                throw new JsonException(RMResources.SpatialBoundingBoxInvalidCoordinates);
+            }
+
+            return new BoundingBox(
+                new Position(coordinates.Take(coordinates.Length / 2).ToList()),
+                new Position(coordinates.Skip(coordinates.Length / 2).ToList()));
+        }
+
+        /// <summary>
+        /// Serializes a BoundingBox to a JSON array.
+        /// Outputs min coordinates followed by max coordinates.
+        /// </summary>
+        public override void Write(Utf8JsonWriter writer, BoundingBox box, JsonSerializerOptions options)
+        {
+            writer.WriteStartArray();
+            foreach (double coordinate in box.Min.Coordinates.Concat(box.Max.Coordinates))
+            {
+                // Check if the number is effectively an integer.
+                if (coordinate == Math.Truncate(coordinate))
+                {
+                    // If so, write it with one decimal place to match Newtonsoft's [x.0] format.
+                    writer.WriteRawValue(coordinate.ToString("0.0", CultureInfo.InvariantCulture));
+                }
+                else
+                {
+                    writer.WriteRawValue(coordinate.ToString("R", CultureInfo.InvariantCulture));
+                }
+            }
+            writer.WriteEndArray();
+        }
+    }
+}

Microsoft.Azure.Cosmos/src/Spatial/Converters/STJConverters/CrsSTJConverter.cs

@@ -0,0 +1,128 @@
+// ------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+// ------------------------------------------------------------
+
+namespace Microsoft.Azure.Cosmos.Spatial.Converters.STJConverters
+{
+    using System;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using Microsoft.Azure.Documents;
+    /// <summary>
+    /// Converter used to support System.Text.Json serialization/deserialization of Crs (Coordinate Reference System).
+    /// Handles NamedCrs, LinkedCrs, and Unspecified CRS types.
+    /// Ensures output format matches Newtonsoft.Json exactly.
+    /// </summary>
+    internal sealed class CrsSTJConverter : JsonConverter<Crs>
+    {
+        public override bool HandleNull => true;
+
+        /// <summary>
+        /// Deserializes a CRS from JSON.
+        /// Supports named CRS (e.g., EPSG:4326) and linked CRS with optional type.
+        /// Returns Crs.Unspecified for null values.
+        /// </summary>
+        public override Crs Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType == JsonTokenType.Null)
+            {
+                return Crs.Unspecified;
+            }
+
+            if (reader.TokenType != JsonTokenType.StartObject)
+            {
+                throw new JsonException(RMResources.JsonUnexpectedToken);
+            }
+
+            JsonElement rootElement = JsonDocument.ParseValue(ref reader).RootElement;
+            if (!rootElement.TryGetProperty(STJMetaDataFields.Properties, out JsonElement properties) || (properties.ValueKind != JsonValueKind.Object))
+            {
+                throw new JsonException(RMResources.SpatialFailedToDeserializeCrs);
+            }
+
+            if (!rootElement.TryGetProperty(STJMetaDataFields.Type, out JsonElement crsType) || crsType.ValueKind != JsonValueKind.String)
+            {
+                throw new JsonException(RMResources.SpatialFailedToDeserializeCrs);
+            }
+
+            switch (crsType.GetString())
+            {
+                case "name":
+                    if (!properties.TryGetProperty(STJMetaDataFields.Name, out JsonElement crsName) || crsName.ValueKind != JsonValueKind.String)
+                    {
+                        throw new JsonException(RMResources.SpatialFailedToDeserializeCrs);
+                    }
+                    return new NamedCrs(crsName.GetString());
+
+                case "link":
+                    if (!properties.TryGetProperty(STJMetaDataFields.Href, out JsonElement crsHref) || crsHref.ValueKind != JsonValueKind.String)
+                    {
+                        throw new JsonException(RMResources.SpatialFailedToDeserializeCrs);
+                    }
+
+                    if (properties.TryGetProperty(STJMetaDataFields.Type, out JsonElement crsHrefType))
+                    {
+                        if (crsHrefType.ValueKind != JsonValueKind.String)
+                        {
+                            throw new JsonException(RMResources.SpatialFailedToDeserializeCrs);
+                        }
+                        return new LinkedCrs(crsHref.GetString(), crsHrefType.GetString());
+                    }
+                    return new LinkedCrs(crsHref.GetString());
+
+                default:
+                    throw new JsonException(RMResources.SpatialFailedToDeserializeCrs);
+            }
+
+        }
+        /// <summary>
+        /// Serializes a CRS to JSON.
+        /// Outputs different JSON structures based on CRS type (Named, Linked, or Unspecified).
+        /// </summary>
+        public override void Write(Utf8JsonWriter writer, Crs crs, JsonSerializerOptions options)
+        {
+            if (crs == null)
+            {
+                writer.WriteNullValue();
+                return;
+            }
+
+            switch (crs.Type)
+            {
+                case CrsType.Linked:
+                    {
+                        writer.WriteStartObject();
+                        LinkedCrs linkedCrs = (LinkedCrs)crs;
+                        writer.WriteString(STJMetaDataFields.Type, "link");
+                        writer.WritePropertyName(STJMetaDataFields.Properties);
+                        writer.WriteStartObject();
+                        writer.WriteString(STJMetaDataFields.Href, linkedCrs.Href);
+                        if (linkedCrs.HrefType != null)
+                        {
+                            writer.WriteString(STJMetaDataFields.Type, linkedCrs.HrefType);
+                        }
+
+                        writer.WriteEndObject();
+                        writer.WriteEndObject();
+                        break;
+                    }
+                case CrsType.Named:
+                    {
+                        writer.WriteStartObject();
+                        NamedCrs namedCrs = (NamedCrs)crs;
+                        writer.WriteString(STJMetaDataFields.Type, "name");
+                        writer.WritePropertyName(STJMetaDataFields.Properties);
+                        writer.WriteStartObject();
+                        writer.WriteString(STJMetaDataFields.Name, namedCrs.Name);
+                        writer.WriteEndObject();
+                        writer.WriteEndObject();
+                        break;
+                    }
+                case CrsType.Unspecified:
+                    writer.WriteNullValue();
+                    break;
+            }
+
+        }
+    }
+}