Merge branch 'main' into dev/neeraj-sharma2592/fixNameAttributeInvalidExceptionBug1680

Author: Aniruddh25

README.md

@@ -5,7 +5,7 @@
 [![Documentation](https://img.shields.io/badge/docs-website-%23fc0)](https://learn.microsoft.com/azure/data-api-builder/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
-Latest stable version of Data API builder is **0.8.50** [What's new?](https://learn.microsoft.com/azure/data-api-builder/whats-new)
+Latest stable version of Data API builder is **0.8.51** [What's new?](https://learn.microsoft.com/azure/data-api-builder/whats-new)
 
 ## About
 

src/Cli.Tests/ConfigGeneratorTests.cs

@@ -177,8 +177,8 @@ public void TestSpecialCharactersInConnectionString()
             }");
 
         expectedRuntimeConfigJson = expectedRuntimeConfigJson.Replace(" ", string.Empty);
-        expectedRuntimeConfigJson = expectedRuntimeConfigJson.Replace("\n", string.Empty);
         expectedRuntimeConfigJson = expectedRuntimeConfigJson.Replace("\r\n", string.Empty);
+        expectedRuntimeConfigJson = expectedRuntimeConfigJson.Replace("\n", string.Empty);
 
         Assert.IsTrue(TryGenerateConfig(options, _runtimeConfigLoader!, _fileSystem!));
 

src/Cli.Tests/EndToEndTests.cs

@@ -108,7 +108,7 @@ public void TestInitForCosmosDBPostgreSql()
     [TestMethod]
     public void TestInitializingRestAndGraphQLGlobalSettings()
     {
-        string[] args = { "init", "-c", TEST_RUNTIME_CONFIG_FILE, "--connection-string", SAMPLE_TEST_CONN_STRING, "--database-type", "mssql", "--rest.path", "/rest-api", "--rest.disabled", "--graphql.path", "/graphql-api" };
+        string[] args = { "init", "-c", TEST_RUNTIME_CONFIG_FILE, "--connection-string", SAMPLE_TEST_CONN_STRING, "--database-type", "mssql", "--rest.path", "/rest-api", "--rest.enabled", "false", "--graphql.path", "/graphql-api" };
         Program.Execute(args, _cliLogger!, _fileSystem!, _runtimeConfigLoader!);
 
         Assert.IsTrue(_runtimeConfigLoader!.TryLoadConfig(
@@ -768,4 +768,65 @@ public void TestBaseRouteIsConfigurableForSWA(string authProvider, bool isExcept
             Assert.AreEqual("/base-route", runtimeConfig.Runtime.BaseRoute);
         }
     }
+
+    [DataTestMethod]
+    [DataRow(ApiType.REST, false, false, true, true, DisplayName = "Validate that REST endpoint is enabled when both enabled and disabled options are omitted from the init command.")]
+    [DataRow(ApiType.REST, false, true, true, true, DisplayName = "Validate that REST endpoint is enabled when enabled option is set to true and disabled option is omitted from the init command.")]
+    [DataRow(ApiType.REST, true, false, true, false, DisplayName = "Validate that REST endpoint is disabled when enabled option is omitted and disabled option is included in the init command.")]
+    [DataRow(ApiType.REST, true, true, false, false, DisplayName = "Validate that REST endpoint is disabled when enabled option is set to false and disabled option is included in the init command.")]
+    [DataRow(ApiType.REST, true, true, true, true, true, DisplayName = "Validate that config generation fails when enabled and disabled options provide conflicting values for REST endpoint.")]
+    [DataRow(ApiType.GraphQL, false, false, true, true, DisplayName = "Validate that GraphQL endpoint is enabled when both enabled and disabled options are omitted from the init command.")]
+    [DataRow(ApiType.GraphQL, false, true, true, true, DisplayName = "Validate that GraphQL endpoint is enabled when enabled option is set to true and disabled option is omitted from the init command.")]
+    [DataRow(ApiType.GraphQL, true, false, true, false, DisplayName = "Validate that GraphQL endpoint is disabled when enabled option is omitted and disabled option is included in the init command.")]
+    [DataRow(ApiType.GraphQL, true, true, false, false, DisplayName = "Validate that GraphQL endpoint is disabled when enabled option is set to false and disabled option is included in the init command.")]
+    [DataRow(ApiType.GraphQL, true, true, true, true, true, DisplayName = "Validate that config generation fails when enabled and disabled options provide conflicting values for GraphQL endpoint.")]
+    public void TestEnabledDisabledFlagsForApis(
+        ApiType apiType,
+        bool includeDisabledFlag,
+        bool includeEnabledFlag,
+        bool enabledFlagValue,
+        bool expectedEnabledFlagValueInConfig,
+        bool isExceptionExpected = false)
+    {
+        string apiName = apiType.ToString().ToLower();
+        string disabledFlag = $"--{apiName}.disabled";
+        string enabledFlag = $"--{apiName}.enabled";
+
+        string[] initArgs = { "init", "-c", TEST_RUNTIME_CONFIG_FILE, "--database-type", "mssql", "--connection-string", SAMPLE_TEST_CONN_STRING };
+
+        string[] enabledDisabledArgs = { };
+
+        if (includeDisabledFlag)
+        {
+            enabledDisabledArgs = enabledDisabledArgs.Append(disabledFlag).ToArray();
+        }
+
+        if (includeEnabledFlag)
+        {
+            enabledDisabledArgs = enabledDisabledArgs.Append(enabledFlag).ToArray();
+            enabledDisabledArgs = enabledDisabledArgs.Append(enabledFlagValue.ToString()).ToArray();
+        }
+
+        initArgs = initArgs.Concat(enabledDisabledArgs).ToArray();
+        Program.Execute(initArgs, _cliLogger!, _fileSystem!, _runtimeConfigLoader!);
+        if (isExceptionExpected)
+        {
+            Assert.IsFalse(_runtimeConfigLoader!.TryLoadConfig(TEST_RUNTIME_CONFIG_FILE, out RuntimeConfig? runtimeConfig));
+            Assert.IsNull(runtimeConfig);
+        }
+        else
+        {
+            Assert.IsTrue(_runtimeConfigLoader!.TryLoadConfig(TEST_RUNTIME_CONFIG_FILE, out RuntimeConfig? runtimeConfig));
+            Assert.IsNotNull(runtimeConfig);
+
+            if (apiType is ApiType.REST)
+            {
+                Assert.AreEqual(expectedEnabledFlagValueInConfig, runtimeConfig.Runtime.Rest.Enabled);
+            }
+            else
+            {
+                Assert.AreEqual(expectedEnabledFlagValueInConfig, runtimeConfig.Runtime.GraphQL.Enabled);
+            }
+        }
+    }
 }

src/Cli.Tests/InitTests.cs

@@ -152,6 +152,8 @@ bool expectSuccess
                 hostMode: HostMode.Production,
                 corsOrigin: null,
                 authenticationProvider: EasyAuthType.StaticWebApps.ToString(),
+                restEnabled: CliBool.True,
+                graphqlEnabled: CliBool.True,
                 config: TEST_RUNTIME_CONFIG_FILE);
 
             Assert.AreEqual(expectSuccess, TryCreateRuntimeConfig(options, _runtimeConfigLoader!, _fileSystem!, out RuntimeConfig? _));
@@ -196,16 +198,18 @@ public void VerifyRequiredOptionsForCosmosDbNoSqlDatabase(
         /// <summary>
         /// Verify that if both REST and GraphQL is disabled, we will get error.
         /// </summary>
-        [DataRow(true, true, false, DisplayName = "Both REST and GraphQL disabled.")]
-        [DataRow(true, false, true, DisplayName = "REST disabled, and GraphQL enabled.")]
-        [DataRow(false, true, true, DisplayName = "REST enabled, and GraphQL disabled.")]
-        [DataRow(false, false, true, DisplayName = "Both REST and GraphQL are enabled.")]
+        [DataRow(CliBool.False, CliBool.False, false, DisplayName = "Both REST and GraphQL disabled.")]
+        [DataRow(CliBool.False, CliBool.True, true, DisplayName = "REST disabled, and GraphQL enabled.")]
+        [DataRow(CliBool.True, CliBool.False, true, DisplayName = "REST enabled, and GraphQL disabled.")]
+        [DataRow(CliBool.True, CliBool.True, true, DisplayName = "Both REST and GraphQL are enabled.")]
         [DataTestMethod]
         public void EnsureFailureWhenBothRestAndGraphQLAreDisabled(
-            bool RestDisabled,
-            bool GraphQLDisabled,
+            CliBool restEnabled,
+            CliBool graphQLEnabled,
             bool expectedResult)
         {
+            bool restDisabled = restEnabled is CliBool.False ? true : false;
+            bool graphQLDisabled = graphQLEnabled is CliBool.False ? true : false;
             InitOptions options = new(
                 databaseType: DatabaseType.MSSQL,
                 connectionString: "testconnectionstring",
@@ -216,13 +220,37 @@ public void EnsureFailureWhenBothRestAndGraphQLAreDisabled(
                 hostMode: HostMode.Production,
                 corsOrigin: null,
                 authenticationProvider: EasyAuthType.StaticWebApps.ToString(),
-                restDisabled: RestDisabled,
-                graphqlDisabled: GraphQLDisabled,
+                restEnabled: restEnabled,
+                graphqlEnabled: graphQLEnabled,
+                restDisabled: restDisabled,
+                graphqlDisabled: graphQLDisabled,
                 config: TEST_RUNTIME_CONFIG_FILE);
 
             Assert.AreEqual(expectedResult, TryCreateRuntimeConfig(options, _runtimeConfigLoader!, _fileSystem!, out RuntimeConfig? _));
         }
 
+        /// <summary>
+        /// Test to verify creation of initial config with special characters
+        /// such as [!,@,#,$,%,^,&,*, ,(,)] in connection-string.
+        /// </summary>
+        [TestMethod]
+        public Task TestSpecialCharactersInConnectionString()
+        {
+            InitOptions options = new(
+                databaseType: DatabaseType.MSSQL,
+                connectionString: "A!string@with#some$special%characters^to&check*proper(serialization)including space.",
+                cosmosNoSqlDatabase: null,
+                cosmosNoSqlContainer: null,
+                graphQLSchemaPath: null,
+                setSessionContext: false,
+                hostMode: HostMode.Production,
+                corsOrigin: null,
+                authenticationProvider: EasyAuthType.StaticWebApps.ToString(),
+                config: TEST_RUNTIME_CONFIG_FILE);
+
+            return ExecuteVerifyTest(options);
+        }
+
         /// <summary>
         /// Test to verify that an error is thrown when user tries to
         /// initialize a config with a file name that already exists.

src/Cli/Commands/InitOptions.cs

@@ -34,6 +34,8 @@ public InitOptions(
             bool restDisabled = false,
             string graphQLPath = GraphQLRuntimeOptions.DEFAULT_PATH,
             bool graphqlDisabled = false,
+            CliBool restEnabled = CliBool.None,
+            CliBool graphqlEnabled = CliBool.None,
             string? config = null)
             : base(config)
         {
@@ -53,6 +55,8 @@ public InitOptions(
             RestDisabled = restDisabled;
             GraphQLPath = graphQLPath;
             GraphQLDisabled = graphqlDisabled;
+            RestEnabled = restEnabled;
+            GraphQLEnabled = graphqlEnabled;
         }
 
         [Option("database-type", Required = true, HelpText = "Type of database to connect. Supported values: mssql, cosmosdb_nosql, cosmosdb_postgresql, mysql, postgresql")]
@@ -103,6 +107,12 @@ public InitOptions(
         [Option("graphql.disabled", Default = false, Required = false, HelpText = "Disables GraphQL endpoint for all entities.")]
         public bool GraphQLDisabled { get; }
 
+        [Option("rest.enabled", Required = false, HelpText = "Enables REST endpoint for all entities. Supported values: true, false.")]
+        public CliBool RestEnabled { get; }
+
+        [Option("graphql.enabled", Required = false, HelpText = "Enables GraphQL endpoint for all entities. Supported values: true, false.")]
+        public CliBool GraphQLEnabled { get; }
+
         public void Handler(ILogger logger, FileSystemRuntimeConfigLoader loader, IFileSystem fileSystem)
         {
             logger.LogInformation("{productName} {version}", PRODUCT_NAME, ProductInfo.GetProductVersion());

src/Cli/ConfigGenerator.cs

@@ -92,13 +92,33 @@ public static bool TryCreateRuntimeConfig(InitOptions options, FileSystemRuntime
             Dictionary<string, JsonElement> dbOptions = new();
 
             HyphenatedNamingPolicy namingPolicy = new();
-            bool restDisabled = options.RestDisabled;
+
+            // If --rest.disabled flag is included in the init command, we log a warning to not use this flag as it will be deprecated in future versions of DAB.
+            if (options.RestDisabled is true)
+            {
+                _logger.LogWarning("The option --rest.disabled will be deprecated and support for the option will be removed in future versions of Data API builder." +
+                    " We recommend that you use the --rest.enabled option instead.");
+            }
+
+            // If --graphql.disabled flag is included in the init command, we log a warning to not use this flag as it will be deprecated in future versions of DAB.
+            if (options.GraphQLDisabled is true)
+            {
+                _logger.LogWarning("The option --graphql.disabled will be deprecated and support for the option will be removed in future versions of Data API builder." +
+                    " We recommend that you use the --graphql.enabled option instead.");
+            }
+
+            bool restEnabled, graphQLEnabled;
+            if (!TryDetermineIfApiIsEnabled(options.RestDisabled, options.RestEnabled, ApiType.REST, out restEnabled) ||
+                !TryDetermineIfApiIsEnabled(options.GraphQLDisabled, options.GraphQLEnabled, ApiType.GraphQL, out graphQLEnabled))
+            {
+                return false;
+            }
 
             switch (dbType)
             {
                 case DatabaseType.CosmosDB_NoSQL:
                     // If cosmosdb_nosql is specified, rest is disabled.
-                    restDisabled = true;
+                    restEnabled = false;
 
                     string? cosmosDatabase = options.CosmosNoSqlDatabase;
                     string? cosmosContainer = options.CosmosNoSqlContainer;
@@ -206,8 +226,8 @@ public static bool TryCreateRuntimeConfig(InitOptions options, FileSystemRuntime
                 Schema: dabSchemaLink,
                 DataSource: dataSource,
                 Runtime: new(
-                    Rest: new(!restDisabled, restPath ?? RestRuntimeOptions.DEFAULT_PATH),
-                    GraphQL: new(!options.GraphQLDisabled, graphQLPath),
+                    Rest: new(restEnabled, restPath ?? RestRuntimeOptions.DEFAULT_PATH),
+                    GraphQL: new(graphQLEnabled, graphQLPath),
                     Host: new(
                         Cors: new(options.CorsOrigin?.ToArray() ?? Array.Empty<string>()),
                         Authentication: new(
@@ -221,6 +241,45 @@ public static bool TryCreateRuntimeConfig(InitOptions options, FileSystemRuntime
             return true;
         }
 
+        /// <summary>
+        /// Helper method to determine if the api is enabled or not based on the enabled/disabled options in the dab init command.
+        /// The method also validates that there is no mismatch in semantics of enabling/disabling the REST/GraphQL API(s)
+        /// based on the values supplied in the enabled/disabled options for the API in the init command.
+        /// </summary>
+        /// <param name="apiDisabledOptionValue">Value of disabled option as in the init command. If the option is omitted in the command, default value is assigned.</param>
+        /// <param name="apiEnabledOptionValue">Value of enabled option as in the init command. If the option is omitted in the command, default value is assigned.</param>
+        /// <param name="apiType">ApiType - REST/GraphQL.</param>
+        /// <param name="isApiEnabled">Boolean value indicating whether the API endpoint is enabled or not.</param>
+        private static bool TryDetermineIfApiIsEnabled(bool apiDisabledOptionValue, CliBool apiEnabledOptionValue, ApiType apiType, out bool isApiEnabled)
+        {
+            if (!apiDisabledOptionValue)
+            {
+                isApiEnabled = apiEnabledOptionValue == CliBool.False ? false : true;
+                // This indicates that the --api.disabled option was not included in the init command.
+                // In such a case, we honor the --api.enabled option.
+                return true;
+            }
+
+            if (apiEnabledOptionValue is CliBool.None)
+            {
+                // This means that the --api.enabled option was not included in the init command.
+                isApiEnabled = !apiDisabledOptionValue;
+                return true;
+            }
+
+            // We hit this code only when both --api.enabled and --api.disabled flags are included in the init command.
+            isApiEnabled = bool.Parse(apiEnabledOptionValue.ToString());
+            if (apiDisabledOptionValue == isApiEnabled)
+            {
+                string apiName = apiType.ToString().ToLower();
+                _logger.LogError($"Config generation failed due to mismatch in the semantics of enabling {apiType} API via " +
+                    $"--{apiName}.disabled and --{apiName}.enabled options");
+                return false;
+            }
+
+            return true;
+        }
+
         /// <summary>
         /// This method will add a new Entity with the given REST and GraphQL endpoints, source, and permissions.
         /// It also supports fields that needs to be included or excluded for a given role and operation.

src/Config/ObjectModel/CliBool.cs

@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Azure.DataApiBuilder.Config.ObjectModel
+{
+    public enum CliBool
+    {
+        // The enum value None is required to determine whether a value was provided for a CLI option. In case the option is not included in the init command,
+        // the enum gets assigned a value of an uninitialized enum i.e. 0 (here 'None').
+        None,
+        True,
+        False
+    }
+}