Fix to #21006 - Support a default value for non-nullable properties

Only for scalar properties when projecting Json-mapped entity.
Only need to change code for Cosmos - relational already works in the desired way after the change to streaming (properties that are not encountered maintain their default value)
We still throw exception if JSON contains explicit null where non-nullable scalar is expected.

Fixes #21006

Author: maumar

Diff for: src/EFCore.Cosmos/Query/Internal/CosmosShapedQueryCompilingExpressionVisitor.CosmosProjectionBindingRemovingExpressionVisitorBase.cs

@@ -691,7 +691,7 @@ private Expression CreateGetValueExpression(
                 && !property.IsShadowProperty())
             {
                 var readExpression = CreateGetValueExpression(
-                    jTokenExpression, storeName, type.MakeNullable(), property.GetTypeMapping());
+                    jTokenExpression, storeName, type.MakeNullable(), property.GetTypeMapping(), !property.IsNullable);
 
                 var nonNullReadExpression = readExpression;
                 if (nonNullReadExpression.Type != type)
@@ -712,15 +712,23 @@ private Expression CreateGetValueExpression(
             }
 
             return Convert(
-                CreateGetValueExpression(jTokenExpression, storeName, type.MakeNullable(), property.GetTypeMapping()),
+                CreateGetValueExpression(
+                    jTokenExpression,
+                    storeName,
+                    type.MakeNullable(),
+                    property.GetTypeMapping(),
+                    isNonNullableScalar: !property.IsNullable && !property.IsKey()),
                 type);
         }
 
+//        private readonly static PropertyInfo JTokenTypePropertyInfo = typeof(JToken).GetProperty(nameof(JToken.Type))!; 
+
         private Expression CreateGetValueExpression(
             Expression jTokenExpression,
             string storeName,
             Type type,
-            CoreTypeMapping typeMapping = null)
+            CoreTypeMapping typeMapping = null,
+            bool isNonNullableScalar = false)
         {
             Check.DebugAssert(type.IsNullableType(), "Must read nullable type from JObject.");
 
@@ -763,6 +771,23 @@ var body
                             Constant(CosmosClientWrapper.Serializer)),
                         converter.ConvertFromProviderExpression.Body);
 
+                //if (isNonNullableScalar)
+                //{
+                //    //same logic as SafeToObjectWithSerializer
+                //    //token == null || token.Type == JTokenType.Null ? default : body
+                //    body = Expression.Condition(
+                //        Expression.OrElse(
+                //            Expression.Equal(
+                //                jTokenParameter,
+                //                Expression.Constant(null, typeof(JToken))),
+                //            Expression.Equal(
+                //                Expression.Property(jTokenParameter, JTokenTypePropertyInfo),
+                //                Expression.Constant(JTokenType.Null))),
+                //        Expression.Default(body.Type),
+                //        body);
+                //}
+
+                var originalBodyType = body.Type;
                 if (body.Type != type)
                 {
                     body = Convert(body, type);
@@ -783,7 +808,11 @@ var body
                 }
                 else
                 {
-                    replaceExpression = Default(type);
+                    replaceExpression = isNonNullableScalar
+                        ? Expression.Convert(
+                            Default(originalBodyType),
+                            type)
+                        : Default(type);
                 }
 
                 body = Condition(
@@ -799,7 +828,11 @@ var body
             }
             else
             {
-                valueExpression = ConvertJTokenToType(jTokenExpression, typeMapping?.ClrType.MakeNullable() ?? type);
+                valueExpression = ConvertJTokenToType(
+                    jTokenExpression,
+                    (isNonNullableScalar
+                        ? typeMapping?.ClrType
+                        : typeMapping?.ClrType.MakeNullable()) ?? type);
 
                 if (valueExpression.Type != type)
                 {

Diff for: test/EFCore.Cosmos.FunctionalTests/Query/AdHocCosmosTestHelpers.cs

@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Net;
+using Microsoft.Azure.Cosmos;
+using Microsoft.EntityFrameworkCore.Cosmos.Storage.Internal;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace Microsoft.EntityFrameworkCore.Query;
+
+public class AdHocCosmosTestHelpers
+{
+    public static async Task CreateCustomEntityHelperAsync(
+        Container container,
+        string json,
+        CancellationToken cancellationToken)
+    {
+        var document = JObject.Parse(json);
+
+        var stream = new MemoryStream();
+        await using var __ = stream.ConfigureAwait(false);
+        var writer = new StreamWriter(stream, new UTF8Encoding(), bufferSize: 1024, leaveOpen: false);
+        await using var ___ = writer.ConfigureAwait(false);
+        using var jsonWriter = new JsonTextWriter(writer);
+
+        CosmosClientWrapper.Serializer.Serialize(jsonWriter, document);
+        await jsonWriter.FlushAsync(cancellationToken).ConfigureAwait(false);
+
+        var response = await container.CreateItemStreamAsync(
+                stream,
+                PartitionKey.None,
+                requestOptions: null,
+                cancellationToken)
+            .ConfigureAwait(false);
+
+
+        if (response.StatusCode != HttpStatusCode.Created)
+        {
+            throw new InvalidOperationException($"Failed to create entitty (status code: {response.StatusCode}) for json: {json}");
+        }
+    }
+}