[Configuration] Initialize optional properties with defaults (#1684)

## Why make this change?

- As per the JSON config schema, not all properties in the config file
are mandatory.
- With #1402, in versions 0.8.49+ those properties that are not
explicitly set, are initialized with defaults before writing to the file
system.
- However, config files generated using version 0.7.6 or lesser, may not
have these properties initialized to their defaults when writing to the
file system. Using config files generated with <= 0.7.6, to start engine
with 0.8.49 would therefore lead to null reference exceptions when the
optional properties are dereferenced.
- This PR is to ensure such null reference exceptions are avoided when
starting engine with configs that don't have optional properties

## What is this change?
- Modify object model constructors to accept nullable arguments for
optional properties - represented as fields in the record types. If
passed in argument is null, initialize the field with default values. Do
this recursively for sub-properties.
- To force JSON deserializer to pick up the custom constructor, add
`IncludeFields = true` to `JsonSerializerOptions`
- Default value of host mode is changed to `development` since
`allow-introspection` has a default value of `true`

## How was this tested?
- Removed optional properties from config and ensured engine could be
started without them.
- [X] Unit Tests

## Sample Request(s)

- remove `runtime` section from config, starting engine with 0.8.49
leads to NullReferenceException.
- After the fix, starting engine is successful even when `runtime`
section is absent in the config.

Author: Aniruddh25

schemas/dab.draft.schema.json

@@ -161,7 +161,7 @@
             "mode": {
               "description": "Set if running in Development or Production mode",
               "type": "string",
-              "default": "production",
+              "default": "development",
               "enum": [
                 "production",
                 "development"

src/Cli.Tests/TestHelper.cs

@@ -870,7 +870,7 @@ public static Process ExecuteDabCommand(string command, string flags)
           ""graphql"": {
             ""path"": ""/graphql"",
             ""enabled"": true,
-            ""allow-introspection"": true
+            ""allow-introspection"": false
           },
           ""host"": {
             ""mode"": ""production"",
@@ -917,11 +917,6 @@ public static Process ExecuteDabCommand(string command, string flags)
           ""connection-string"": ""localhost:5000;User ID={USER_NAME};Password={USER_PASSWORD};MultipleActiveResultSets=False;""
         },
         ""runtime"": {
-          ""graphql"": {
-            ""path"": ""/graphql"",
-            ""enabled"": true,
-            ""allow-introspection"": true
-          },
           ""host"": {
             ""mode"": ""production"",
             ""cors"": {
@@ -990,7 +985,7 @@ public static Process ExecuteDabCommand(string command, string flags)
           ""graphql"": {
             ""path"": ""/graphql"",
             ""enabled"": true,
-            ""allow-introspection"": true
+            ""allow-introspection"": false
           },
           ""host"": {
             ""mode"": ""production"",

src/Cli/Utils.cs

@@ -203,50 +203,6 @@ public static bool IsURIComponentValid(string? uriComponent)
             return !DoesUriComponentContainReservedChars(uriComponent);
         }
 
-        /// <summary>
-        /// Returns the default host Global Settings
-        /// If the user doesn't specify host mode. Default value to be used is Production.
-        /// Sample:
-        // "host": {
-        //     "mode": "production",
-        //     "cors": {
-        //         "origins": [],
-        //         "allow-credentials": true
-        //     },
-        //     "authentication": {
-        //         "provider": "StaticWebApps"
-        //     }
-        // }
-        /// </summary>
-        public static HostOptions GetDefaultHostOptions(
-            HostMode hostMode,
-            IEnumerable<string>? corsOrigin,
-            string authenticationProvider,
-            string? audience,
-            string? issuer)
-        {
-            string[]? corsOriginArray = corsOrigin is null ? new string[] { } : corsOrigin.ToArray();
-            CorsOptions cors = new(Origins: corsOriginArray);
-            AuthenticationOptions AuthenticationOptions;
-            if (Enum.TryParse<EasyAuthType>(authenticationProvider, ignoreCase: true, out _)
-                || AuthenticationOptions.SIMULATOR_AUTHENTICATION.Equals(authenticationProvider))
-            {
-                AuthenticationOptions = new(Provider: authenticationProvider, null);
-            }
-            else
-            {
-                AuthenticationOptions = new(
-                    Provider: authenticationProvider,
-                    Jwt: new(audience, issuer)
-                );
-            }
-
-            return new(
-                Mode: hostMode,
-                Cors: cors,
-                Authentication: AuthenticationOptions);
-        }
-
         /// <summary>
         /// Returns an object of type Policy
         /// If policyRequest or policyDatabase is provided. Otherwise, returns null.

src/Config/ObjectModel/AuthenticationOptions.cs

@@ -11,7 +11,7 @@ namespace Azure.DataApiBuilder.Config.ObjectModel;
 /// </param>
 /// <param name="Jwt">Settings enabling validation of the received JWT token.
 /// Required only when Provider is other than EasyAuth.</param>
-public record AuthenticationOptions(string Provider, JwtOptions? Jwt)
+public record AuthenticationOptions(string Provider = nameof(EasyAuthType.StaticWebApps), JwtOptions? Jwt = null)
 {
     public const string SIMULATOR_AUTHENTICATION = "Simulator";
     public const string CLIENT_PRINCIPAL_HEADER = "X-MS-CLIENT-PRINCIPAL";

src/Config/ObjectModel/CorsOptions.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Text.Json.Serialization;
+
 namespace Azure.DataApiBuilder.Config.ObjectModel;
 
 /// <summary>
@@ -9,4 +11,16 @@ namespace Azure.DataApiBuilder.Config.ObjectModel;
 /// <param name="Origins">List of allowed origins.</param>
 /// <param name="AllowCredentials">
 /// Whether to set Access-Control-Allow-Credentials CORS header.</param>
-public record CorsOptions(string[] Origins, bool AllowCredentials = false);
+public record CorsOptions
+{
+    public string[] Origins;
+
+    public bool AllowCredentials;
+
+    [JsonConstructor]
+    public CorsOptions(string[]? Origins, bool AllowCredentials = false)
+    {
+        this.Origins = Origins is null ? new string[] { } : Origins.ToArray();
+        this.AllowCredentials = AllowCredentials;
+    }
+}

src/Config/ObjectModel/HostOptions.cs

@@ -3,4 +3,49 @@
 
 namespace Azure.DataApiBuilder.Config.ObjectModel;
 
-public record HostOptions(CorsOptions? Cors, AuthenticationOptions? Authentication, HostMode Mode = HostMode.Development);
+public record HostOptions(CorsOptions? Cors, AuthenticationOptions? Authentication, HostMode Mode = HostMode.Development)
+{
+    /// <summary>
+    /// Returns the default host Global Settings
+    /// If the user doesn't specify host mode. Default value to be used is Development.
+    /// Sample:
+    // "host": {
+    //     "mode": "development",
+    //     "cors": {
+    //         "origins": [],
+    //         "allow-credentials": true
+    //     },
+    //     "authentication": {
+    //         "provider": "StaticWebApps"
+    //     }
+    // }
+    /// </summary>
+    public static HostOptions GetDefaultHostOptions(
+        HostMode hostMode,
+        IEnumerable<string>? corsOrigin,
+        string authenticationProvider,
+        string? audience,
+        string? issuer)
+    {
+        string[]? corsOriginArray = corsOrigin is null ? new string[] { } : corsOrigin.ToArray();
+        CorsOptions cors = new(Origins: corsOriginArray);
+        AuthenticationOptions AuthenticationOptions;
+        if (Enum.TryParse<EasyAuthType>(authenticationProvider, ignoreCase: true, out _)
+            || AuthenticationOptions.SIMULATOR_AUTHENTICATION.Equals(authenticationProvider))
+        {
+            AuthenticationOptions = new(Provider: authenticationProvider, Jwt: null);
+        }
+        else
+        {
+            AuthenticationOptions = new(
+                Provider: authenticationProvider,
+                Jwt: new(audience, issuer)
+            );
+        }
+
+        return new(
+            Mode: hostMode,
+            Cors: cors,
+            Authentication: AuthenticationOptions);
+    }
+}

src/Config/ObjectModel/RuntimeConfig.cs

@@ -13,6 +13,8 @@ public record RuntimeConfig
     [JsonPropertyName("$schema")]
     public string Schema { get; init; }
 
+    public const string DEFAULT_CONFIG_SCHEMA_LINK = "https://github.com/Azure/data-api-builder/releases/download/vmajor.minor.patch/dab.draft.schema.json";
+
     public DataSource DataSource { get; init; }
 
     public RuntimeOptions Runtime { get; init; }
@@ -50,11 +52,15 @@ public IEnumerable<KeyValuePair<string, DataSource>> GetDataSourceNamesToDataSou
     /// <param name="Runtime">Runtime settings.</param>
     /// <param name="Entities">Entities</param>
     [JsonConstructor]
-    public RuntimeConfig(string Schema, DataSource DataSource, RuntimeOptions Runtime, RuntimeEntities Entities)
+    public RuntimeConfig(string? Schema, DataSource DataSource, RuntimeEntities Entities, RuntimeOptions? Runtime = null)
     {
-        this.Schema = Schema;
+        this.Schema = Schema ?? DEFAULT_CONFIG_SCHEMA_LINK;
         this.DataSource = DataSource;
-        this.Runtime = Runtime;
+        this.Runtime = Runtime ??
+           new RuntimeOptions(
+               new RestRuntimeOptions(Enabled: DataSource.DatabaseType != DatabaseType.CosmosDB_NoSQL),
+               GraphQL: null, // even though we pass null here, the constructor will take care of initializing with defaults.
+               Host: null);
         this.Entities = Entities;
         this._dataSourceNameToDataSource = new Dictionary<string, DataSource>();
         this._defaultDataSourceName = Guid.NewGuid().ToString();

src/Config/ObjectModel/RuntimeOptions.cs

@@ -1,6 +1,27 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Text.Json.Serialization;
+
 namespace Azure.DataApiBuilder.Config.ObjectModel;
 
-public record RuntimeOptions(RestRuntimeOptions Rest, GraphQLRuntimeOptions GraphQL, HostOptions Host, string? BaseRoute = null);
+public record RuntimeOptions
+{
+    public RestRuntimeOptions Rest;
+    public GraphQLRuntimeOptions GraphQL;
+    public HostOptions Host;
+    public string? BaseRoute;
+
+    [JsonConstructor]
+    public RuntimeOptions(RestRuntimeOptions? Rest, GraphQLRuntimeOptions? GraphQL, HostOptions? Host, string? BaseRoute = null)
+    {
+        this.Rest = Rest ?? new RestRuntimeOptions();
+        this.GraphQL = GraphQL ?? new GraphQLRuntimeOptions();
+        this.Host = Host ?? HostOptions.GetDefaultHostOptions(
+            HostMode.Development,
+            corsOrigin: null,
+            EasyAuthType.StaticWebApps.ToString(),
+            audience: null, issuer: null);
+        this.BaseRoute = BaseRoute;
+    }
+}

src/Config/RuntimeConfigLoader.cs

@@ -155,7 +155,8 @@ public static JsonSerializerOptions GetSerializationOptions(bool replaceEnvVar =
             PropertyNamingPolicy = new HyphenatedNamingPolicy(),
             ReadCommentHandling = JsonCommentHandling.Skip,
             WriteIndented = true,
-            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
+            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+            IncludeFields = true
         };
         options.Converters.Add(new EnumMemberJsonEnumConverterFactory());
         options.Converters.Add(new RestRuntimeOptionsConverterFactory());

src/Service.Tests/Configuration/ConfigurationTests.cs

@@ -2270,8 +2270,8 @@ private static JsonContent GetPostStartupConfigParams(string environment, Runtim
                 RuntimeConfig overrides = new(
                     Schema: null,
                     DataSource: new DataSource(DatabaseType.MSSQL, connectionString, new()),
-                    Runtime: null,
-                    Entities: new(new Dictionary<string, Entity>()));
+                    Entities: new(new Dictionary<string, Entity>()),
+                    Runtime: null);
 
                 ConfigurationPostParametersV2 returnParams = new(
                     Configuration: serializedConfiguration,

src/Service.Tests/Unittests/RuntimeConfigLoaderJsonDeserializerTests.cs

@@ -5,6 +5,7 @@
 using System.Data;
 using System.IO;
 using System.IO.Abstractions.TestingHelpers;
+using System.Text;
 using System.Text.Json;
 using Azure.DataApiBuilder.Config;
 using Azure.DataApiBuilder.Config.Converters;
@@ -15,8 +16,7 @@
 namespace Azure.DataApiBuilder.Service.Tests.UnitTests
 {
     /// <summary>
-    /// Unit tests for the environment variable
-    /// parser for the runtime configuration. These
+    /// Unit tests for deserializing the runtime configuration. These
     /// tests verify that we parse the config correctly
     /// when replacing environment variables. Also verify
     /// we throw the right exception when environment
@@ -127,6 +127,34 @@ public void CheckCommentParsingInConfigFile()
             Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(actualJson, out RuntimeConfig _), "Should not fail to parse with comments");
         }
 
+        /// <summary>
+        /// Method to validate that comments are skipped in config file (and are ignored during deserialization).
+        /// </summary>
+        [TestMethod]
+        public void TestDefaultsCreatedForOptionalProps()
+        {
+            // Test with no runtime property
+            StringBuilder minJson = new(@"
+                                ""data-source"": {
+                                    ""database-type"": ""mssql"",
+                                    ""connection-string"": ""@env('test-connection-string')""
+                                    },
+                                ""entities"": { }");
+            TryParseAndAssertOnDefaults("{" + minJson + "}");
+
+            // Test with an empty runtime property
+            minJson.Append(@", ""runtime"": ");
+            TryParseAndAssertOnDefaults("{" + minJson + "{ }}");
+
+            // Test with empty rest, graphql, host properties
+            minJson.Append(@"{ ""rest"": { }, ""graphql"": { }, ""host"" : ");
+            TryParseAndAssertOnDefaults("{" + minJson + "{ } } }", isHostSpecifiedButEmpty: true);
+
+            // Test with empty rest, graphql, and empty host sub-properties
+            minJson.Append(@"{ ""cors"": { }, ""authentication"": { } } }");
+            TryParseAndAssertOnDefaults("{" + minJson + "}", isHostSpecifiedButEmpty: false);
+        }
+
         #endregion Positive Tests
 
         #region Negative Tests
@@ -301,6 +329,31 @@ public static string GetModifiedJsonString(string[] reps, string enumString)
 ";
         }
 
+        private static void TryParseAndAssertOnDefaults(string json, bool isHostSpecifiedButEmpty = false)
+        {
+            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(json, out RuntimeConfig parsedConfig));
+            Assert.AreEqual(RuntimeConfig.DEFAULT_CONFIG_SCHEMA_LINK, parsedConfig.Schema);
+            Assert.IsTrue(parsedConfig.Runtime.Rest.Enabled);
+            Assert.AreEqual(RestRuntimeOptions.DEFAULT_PATH, parsedConfig.Runtime.Rest.Path);
+            Assert.IsTrue(parsedConfig.Runtime.GraphQL.Enabled);
+            Assert.AreEqual(GraphQLRuntimeOptions.DEFAULT_PATH, parsedConfig.Runtime.GraphQL.Path);
+            Assert.IsTrue(parsedConfig.Runtime.GraphQL.AllowIntrospection);
+            Assert.IsNull(parsedConfig.Runtime.BaseRoute);
+            Assert.AreEqual(HostMode.Development, parsedConfig.Runtime.Host.Mode);
+            if (isHostSpecifiedButEmpty)
+            {
+                Assert.IsNull(parsedConfig.Runtime.Host.Cors);
+                Assert.IsNull(parsedConfig.Runtime.Host.Authentication);
+            }
+            else
+            {
+                Assert.AreEqual(0, parsedConfig.Runtime.Host.Cors.Origins.Length);
+                Assert.IsFalse(parsedConfig.Runtime.Host.Cors.AllowCredentials);
+                Assert.AreEqual(EasyAuthType.StaticWebApps.ToString(), parsedConfig.Runtime.Host.Authentication.Provider);
+                Assert.IsNull(parsedConfig.Runtime.Host.Authentication.Jwt);
+            }
+        }
+
         #endregion Helper Functions
 
         record StubJsonType(string Foo);