Adding options section in data-source and removing database specific sections

src/Cli/src/ConfigGenerator.cs

@@ -53,59 +53,47 @@ public static bool TryCreateRuntimeConfig(InitOptions options, out string runtim
             runtimeConfigJson = string.Empty;
 
             DatabaseType dbType = options.DatabaseType;
-            DataSource dataSource = new(dbType);
 
-            // default value of connection-string should be used, i.e Empty-string
-            // if not explicitly provided by the user
-            if (options.ConnectionString is not null)
-            {
-                dataSource.ConnectionString = options.ConnectionString;
-            }
-
-            CosmosDbOptions? cosmosDbOptions = null;
-            MsSqlOptions? msSqlOptions = null;
-            MySqlOptions? mySqlOptions = null;
-            PostgreSqlOptions? postgreSqlOptions = null;
+            CosmosDbOptions? cosmosDbNoSqlOptions = null;
 
             switch (dbType)
             {
                 case DatabaseType.cosmos:
+                case DatabaseType.cosmosdb_nosql:
                     string? cosmosDatabase = options.CosmosDatabase;
                     string? cosmosContainer = options.CosmosContainer;
                     string? graphQLSchemaPath = options.GraphQLSchemaPath;
                     if (string.IsNullOrEmpty(cosmosDatabase) || string.IsNullOrEmpty(graphQLSchemaPath))
                     {
-                        Console.WriteLine($"Provide all the mandatory options for CosmosDB: --cosmos-database, and --graphql-schema");
+                        Console.WriteLine($"Provide all the mandatory options for CosmosDB_NoSql: --cosmos-database, and --graphql-schema");
                         return false;
                     }
 
-                    cosmosDbOptions = new CosmosDbOptions(cosmosDatabase, cosmosContainer, graphQLSchemaPath, GraphQLSchema: null);
+                    cosmosDbNoSqlOptions = new CosmosDbOptions(cosmosDatabase, cosmosContainer, graphQLSchemaPath, GraphQLSchema: null);
                     break;
 
                 case DatabaseType.mssql:
-                    msSqlOptions = new MsSqlOptions();
-                    break;
-
                 case DatabaseType.mysql:
-                    mySqlOptions = new MySqlOptions();
-                    break;
-
                 case DatabaseType.postgresql:
-                    postgreSqlOptions = new PostgreSqlOptions();
+                case DatabaseType.cosmosdb_postgresql:
                     break;
-
                 default:
-                    Console.WriteLine($"DatabaseType: ${dbType} not supported.Please provide a valid database-type.");
-                    return false;
+                    throw new Exception($"DatabaseType: ${dbType} not supported.Please provide a valid database-type.");
+            }
+
+            DataSource dataSource = new(dbType, DbOptions: cosmosDbNoSqlOptions);
+
+            // default value of connection-string should be used, i.e Empty-string
+            // if not explicitly provided by the user
+            if (options.ConnectionString is not null)
+            {
+                dataSource.ConnectionString = options.ConnectionString;
             }
 
             RuntimeConfig runtimeConfig = new(
                 Schema: RuntimeConfig.SCHEMA,
                 DataSource: dataSource,
-                CosmosDb: cosmosDbOptions,
-                MsSql: msSqlOptions,
-                PostgreSql: postgreSqlOptions,
-                MySql: mySqlOptions,
+                CosmosDb: cosmosDbNoSqlOptions,
                 RuntimeSettings: GetDefaultGlobalSettings(
                     options.HostMode,
                     options.CorsOrigin,

src/Cli/test/EndToEndTests.cs

@@ -10,12 +10,12 @@ namespace Cli.Tests;
 public class EndToEndTests
 {
     /// <summary>
-    /// Initializing config for cosmos DB.
+    /// Initializing config for cosmosdb_nosql.
     /// </summary>
     [TestMethod]
-    public void TestInitForCosmosDB()
+    public void TestInitForCosmosDBNoSql()
     {
-        string[] args = { "init", "-c", _testRuntimeConfig, "--database-type", "cosmos",
+        string[] args = { "init", "-c", _testRuntimeConfig, "--database-type", "cosmosdb_nosql",
                           "--connection-string", "localhost:5000", "--authenticate-devmode-requests", "True", "--cosmos-database",
                           "graphqldb", "--cosmos-container", "planet", "--graphql-schema", "schema.gql", "--cors-origin", "localhost:3000,www.nolocalhost.com:80" };
         Program.Main(args);
@@ -24,11 +24,41 @@ public void TestInitForCosmosDB()
 
         Assert.IsNotNull(runtimeConfig);
         Assert.IsTrue(runtimeConfig.GraphQLGlobalSettings.AllowIntrospection);
-        Assert.AreEqual(DatabaseType.cosmos, runtimeConfig.DatabaseType);
-        Assert.IsNotNull(runtimeConfig.CosmosDb);
-        Assert.AreEqual("graphqldb", runtimeConfig.CosmosDb.Database);
-        Assert.AreEqual("planet", runtimeConfig.CosmosDb.Container);
-        Assert.AreEqual("schema.gql", runtimeConfig.CosmosDb.GraphQLSchemaPath);
+        Assert.AreEqual(DatabaseType.cosmosdb_nosql, runtimeConfig.DatabaseType);
+        Assert.IsNotNull(runtimeConfig.DataSource.CosmosDbNoSql);
+        Assert.AreEqual("graphqldb", runtimeConfig.DataSource.CosmosDbNoSql.Database);
+        Assert.AreEqual("planet", runtimeConfig.DataSource.CosmosDbNoSql.Container);
+        Assert.AreEqual("schema.gql", runtimeConfig.DataSource.CosmosDbNoSql.GraphQLSchemaPath);
+        Assert.IsNotNull(runtimeConfig.RuntimeSettings);
+        Assert.AreEqual(true, runtimeConfig.HostGlobalSettings.IsDevModeDefaultRequestAuthenticated);
+        JsonElement jsonRestSettings = (JsonElement)runtimeConfig.RuntimeSettings[GlobalSettingsType.Rest];
+
+        RestGlobalSettings? restGlobalSettings = JsonSerializer.Deserialize<RestGlobalSettings>(jsonRestSettings, RuntimeConfig.SerializerOptions);
+        Assert.IsNotNull(restGlobalSettings);
+        Assert.IsNotNull(runtimeConfig.HostGlobalSettings);
+
+        Assert.IsTrue(runtimeConfig.RuntimeSettings.ContainsKey(GlobalSettingsType.Host));
+        HostGlobalSettings? hostGlobalSettings = JsonSerializer.Deserialize<HostGlobalSettings>((JsonElement)runtimeConfig.RuntimeSettings[GlobalSettingsType.Host], RuntimeConfig.SerializerOptions);
+        Assert.IsNotNull(hostGlobalSettings);
+        CollectionAssert.AreEqual(new string[] { "localhost:3000", "www.nolocalhost.com:80" }, hostGlobalSettings.Cors!.Origins);
+    }
+
+    /// <summary>
+    /// Initializing config for cosmosdb_postgresql.
+    /// </summary>
+    [TestMethod]
+    public void TestInitForCosmosDBPostgreSql()
+    {
+        string[] args = { "init", "-c", _testRuntimeConfig, "--database-type", "cosmosdb_postgresql",
+                          "--connection-string", "localhost:5000", "--authenticate-devmode-requests", "True",
+                          "--cors-origin", "localhost:3000,www.nolocalhost.com:80" };
+        Program.Main(args);
+
+        RuntimeConfig? runtimeConfig = TryGetRuntimeConfig(_testRuntimeConfig);
+
+        Assert.IsNotNull(runtimeConfig);
+        Assert.AreEqual(DatabaseType.cosmosdb_postgresql, runtimeConfig.DatabaseType);
+        Assert.IsNull(runtimeConfig.DataSource.CosmosDbPostgreSql);
         Assert.IsNotNull(runtimeConfig.RuntimeSettings);
         Assert.AreEqual(true, runtimeConfig.HostGlobalSettings.IsDevModeDefaultRequestAuthenticated);
         JsonElement jsonRestSettings = (JsonElement)runtimeConfig.RuntimeSettings[GlobalSettingsType.Rest];

src/Cli/test/InitTests.cs

@@ -39,7 +39,46 @@ public void MssqlDatabase()
             // Adding runtime settings to the above basic config
             string expectedRuntimeConfig = AddPropertiesToJson(
                 _basicRuntimeConfig,
-                GetDefaultTestRuntimeSettingString(DatabaseType.mssql,
+                GetDefaultTestRuntimeSettingString(
+                    HostModeType.Development,
+                    new List<string>() { "http://localhost:3000", "http://nolocalhost:80" },
+                    authenticateDevModeRequest: true)
+            );
+
+            RunTest(options, expectedRuntimeConfig);
+        }
+
+        /// <summary>
+        /// Test the simple init config for cosmosdb_postgresql database.
+        /// </summary>
+        [TestMethod]
+        public void CosmosDbPostgreSqlDatabase()
+        {
+            InitOptions options = new(
+                databaseType: DatabaseType.cosmosdb_postgresql,
+                connectionString: "testconnectionstring",
+                cosmosDatabase: null,
+                cosmosContainer: null,
+                graphQLSchemaPath: null,
+                hostMode: HostModeType.Development,
+                corsOrigin: new List<string>() { "http://localhost:3000", "http://nolocalhost:80" },
+                config: _testRuntimeConfig,
+                devModeDefaultAuth: "true");
+
+            _basicRuntimeConfig =
+            @"{
+                ""$schema"": ""dab.draft.schema.json"",
+                ""data-source"": {
+                    ""database-type"": ""cosmosdb_postgresql"",
+                    ""connection-string"": ""testconnectionstring""
+                },
+                ""entities"": {}
+            }";
+
+            // Adding runtime settings to the above basic config
+            string expectedRuntimeConfig = AddPropertiesToJson(
+                _basicRuntimeConfig,
+                GetDefaultTestRuntimeSettingString(
                     HostModeType.Development,
                     new List<string>() { "http://localhost:3000", "http://nolocalhost:80" },
                     authenticateDevModeRequest: true)
@@ -78,7 +117,7 @@ public void TestInitializingConfigWithoutConnectionString()
             // Adding runtime settings to the above basic config
             string expectedRuntimeConfig = AddPropertiesToJson(
                 _basicRuntimeConfig,
-                GetDefaultTestRuntimeSettingString(DatabaseType.mssql,
+                GetDefaultTestRuntimeSettingString(
                     HostModeType.Development,
                     new List<string>() { "http://localhost:3000", "http://nolocalhost:80" },
                     authenticateDevModeRequest: false)
@@ -87,13 +126,13 @@ public void TestInitializingConfigWithoutConnectionString()
         }
 
         /// <summary>
-        /// Test cosmos db specifc settings like cosmos-database, cosmos-container, cosmos-schema file.
+        /// Test cosmosdb_nosql specifc settings like cosmos-database, cosmos-container, cosmos-schema file.
         /// </summary>
         [TestMethod]
-        public void CosmosDatabase()
+        public void CosmosDbNoSqlDatabase()
         {
             InitOptions options = new(
-                databaseType: DatabaseType.cosmos,
+                databaseType: DatabaseType.cosmosdb_nosql,
                 connectionString: "testconnectionstring",
                 cosmosDatabase: "testdb",
                 cosmosContainer: "testcontainer",
@@ -106,8 +145,13 @@ public void CosmosDatabase()
             _basicRuntimeConfig = @"{
                 ""$schema"": ""dab.draft.schema.json"",
                 ""data-source"": {
-                    ""database-type"": ""cosmos"",
-                    ""connection-string"": ""testconnectionstring""
+                    ""database-type"": ""cosmosdb_nosql"",
+                    ""connection-string"": ""testconnectionstring"",
+                    ""options"": {
+                        ""database"": ""testdb"",
+                        ""container"": ""testcontainer"",
+                        ""schema"": ""schemafile""
+                    }
                 },
                 ""cosmos"": {
                     ""database"": ""testdb"",
@@ -120,7 +164,7 @@ public void CosmosDatabase()
             // Adding runtime settings to the above basic config
             string expectedRuntimeConfig = AddPropertiesToJson(
                 _basicRuntimeConfig,
-                GetDefaultTestRuntimeSettingString(DatabaseType.cosmos));
+                GetDefaultTestRuntimeSettingString());
             RunTest(options, expectedRuntimeConfig);
         }
 
@@ -133,14 +177,14 @@ public void CosmosDatabase()
         [DataRow("testDatabase", null, "", false, DisplayName = "database is provided, container and Schema is null/empty.")]
         [DataRow("testDatabase", null, "testSchema", true, DisplayName = "database and schema provided, container is null/empty.")]
         [DataTestMethod]
-        public void VerifyRequiredOptionsForCosmosDatabase(
+        public void VerifyRequiredOptionsForCosmosDbNoSqlDatabase(
             string? cosmosDatabase,
             string? cosmosContainer,
             string? graphQLSchema,
             bool expectedResult)
         {
             InitOptions options = new(
-                databaseType: DatabaseType.cosmos,
+                databaseType: DatabaseType.cosmosdb_nosql,
                 connectionString: "testconnectionstring",
                 cosmosDatabase: cosmosDatabase,
                 cosmosContainer: cosmosContainer,

src/Cli/test/TestHelper.cs

@@ -417,7 +417,6 @@ public static Process StartDabProcess(string command, string flags)
         /// for json comparison in tests.
         /// </summary>
         public static string GetDefaultTestRuntimeSettingString(
-            DatabaseType databaseType,
             HostModeType hostModeType = HostModeType.Production,
             IEnumerable<string>? corsOrigins = null,
             bool? authenticateDevModeRequest = null)

src/Cli/test/UpdateEntityTests.cs

@@ -1585,10 +1585,6 @@ public void TestVerifyCanUpdateRelationshipInvalidOptions(string db, string card
             RuntimeConfig runtimeConfig = new(
                 Schema: "schema",
                 DataSource: new DataSource(Enum.Parse<DatabaseType>(db)),
-                CosmosDb: null,
-                MsSql: null,
-                PostgreSql: null,
-                MySql: null,
                 RuntimeSettings: new Dictionary<GlobalSettingsType, object>(),
                 Entities: new Dictionary<string, Entity>()
             );
@@ -1639,10 +1635,6 @@ public void EnsureFailure_AddRelationshipToEntityWithDisabledGraphQL()
             RuntimeConfig runtimeConfig = new(
                 Schema: "schema",
                 DataSource: new DataSource(DatabaseType.mssql),
-                CosmosDb: null,
-                MsSql: null,
-                PostgreSql: null,
-                MySql: null,
                 RuntimeSettings: new Dictionary<GlobalSettingsType, object>(),
                 Entities: entityMap
             );

src/Config/DataSource.cs

@@ -1,3 +1,4 @@
+using System.Text.Json;
 using System.Text.Json.Serialization;
 
 namespace Azure.DataApiBuilder.Config
@@ -10,14 +11,56 @@ namespace Azure.DataApiBuilder.Config
     /// will use to connect to the backend database.</param>
     public record DataSource(
         [property: JsonPropertyName(DataSource.DATABASE_PROPERTY_NAME)]
-        DatabaseType DatabaseType)
+        DatabaseType DatabaseType,
+        [property: JsonPropertyName(DataSource.OPTIONS_PROPERTY_NAME)]
+        object? DbOptions = null)
     {
         public const string JSON_PROPERTY_NAME = "data-source";
         public const string DATABASE_PROPERTY_NAME = "database-type";
         public const string CONNSTRING_PROPERTY_NAME = "connection-string";
+        public const string OPTIONS_PROPERTY_NAME = "options";
 
         [property: JsonPropertyName(CONNSTRING_PROPERTY_NAME)]
         public string ConnectionString { get; set; } = string.Empty;
+        public CosmosDbOptions? CosmosDbNoSql { get; set; }
+        public CosmosDbPostgreSqlOptions? CosmosDbPostgreSql { get; set; }
+        public MsSqlOptions? MsSql { get; set; }
+        public PostgreSqlOptions? PostgreSql { get; set; }
+        public MySqlOptions? MySql { get; set; }
+
+        /// <summary>
+        /// Method to populate the database specific options from the "options"
+        /// section in data-source.
+        /// </summary>
+        public void PopulateDbSpecificOptions()
+        {
+            if (DbOptions is null)
+            {
+                return;
+            }
+
+            switch (DatabaseType)
+            {
+                case DatabaseType.cosmos:
+                case DatabaseType.cosmosdb_nosql:
+                    CosmosDbNoSql = ((JsonElement)DbOptions).Deserialize<CosmosDbOptions>(RuntimeConfig.SerializerOptions)!;
+                    break;
+                case DatabaseType.mssql:
+                    MsSql = ((JsonElement)DbOptions).Deserialize<MsSqlOptions>(RuntimeConfig.SerializerOptions)!;
+                    break;
+                case DatabaseType.mysql:
+                    MySql = ((JsonElement)DbOptions).Deserialize<MySqlOptions>(RuntimeConfig.SerializerOptions)!;
+                    break;
+                case DatabaseType.postgresql:
+                    PostgreSql = ((JsonElement)DbOptions).Deserialize<PostgreSqlOptions>(RuntimeConfig.SerializerOptions)!;
+                    break;
+                case DatabaseType.cosmosdb_postgresql:
+                    CosmosDbPostgreSql = ((JsonElement)DbOptions).Deserialize<CosmosDbPostgreSqlOptions>(RuntimeConfig.SerializerOptions)!;
+                    break;
+                default:
+                    throw new Exception($"DatabaseType: ${DatabaseType} not supported.");
+            }
+        }
     }
 
     /// <summary>
@@ -32,6 +75,9 @@ public record CosmosDbOptions(
         string? GraphQLSchema)
     {
         public const string GRAPHQL_SCHEMA_PATH_PROPERTY_NAME = "schema";
+
+        // Keeping the name as cosmos only to provide backwards compatibility.
+        // This property won't be needed going forward.
         public const string JSON_PROPERTY_NAME = nameof(DatabaseType.cosmos);
     }
 
@@ -40,6 +86,7 @@ public record CosmosDbOptions(
     /// </summary>
     public record MsSqlOptions(
         [property: JsonPropertyName("set-session-context")]
+        [property: JsonIgnore]
         bool SetSessionContext = true)
     {
         public const string JSON_PROPERTY_NAME = nameof(DatabaseType.mssql);
@@ -56,6 +103,11 @@ public record PostgreSqlOptions
         public const string JSON_PROPERTY_NAME = nameof(DatabaseType.postgresql);
     }
 
+    /// <summary>
+    /// Options for CosmosDb_PostgresSql database.
+    /// </summary>
+    public record CosmosDbPostgreSqlOptions { }
+
     /// <summary>
     /// Options for MySql database.
     /// </summary>
@@ -70,6 +122,8 @@ public record MySqlOptions
     public enum DatabaseType
     {
         cosmos,
+        cosmosdb_postgresql,
+        cosmosdb_nosql,
         mssql,
         mysql,
         postgresql