Fix: Allow parent config with data-source-files but no data-source

- Make DataSource and Entities parameters nullable in JsonConstructor
- Defer validation when data-source-files is present
- Adopt first child's DataSource as parent default when parent has none
- Final validation ensures at least one DataSource exists after all loading
- Add regression test for issue #2979

Co-authored-by: JerryNixon <1749983+JerryNixon@users.noreply.github.com>

Author: Copilot

src/Config/ObjectModel/RuntimeConfig.cs

@@ -257,61 +257,68 @@ public bool TryGetEntityNameFromPath(string entityPathName, [NotNullWhen(true)]
     [JsonConstructor]
     public RuntimeConfig(
         string? Schema,
-        DataSource DataSource,
-        RuntimeEntities Entities,
+        DataSource? DataSource,
+        RuntimeEntities? Entities,
         RuntimeAutoentities? Autoentities = null,
         RuntimeOptions? Runtime = null,
         DataSourceFiles? DataSourceFiles = null,
         AzureKeyVaultOptions? AzureKeyVault = null)
     {
         this.Schema = Schema ?? DEFAULT_CONFIG_SCHEMA_LINK;
-        this.DataSource = DataSource;
+        this.DataSource = DataSource!;
         this.Runtime = Runtime;
         this.AzureKeyVault = AzureKeyVault;
-        this.Entities = Entities;
+        this.Entities = Entities!;
         this.Autoentities = Autoentities;
         this.DefaultDataSourceName = Guid.NewGuid().ToString();
 
-        if (this.DataSource is null)
+        bool hasDataSourceFiles = DataSourceFiles?.SourceFiles?.Any() == true;
+
+        if (this.DataSource is null && !hasDataSourceFiles)
         {
             throw new DataApiBuilderException(
                 message: "data-source is a mandatory property in DAB Config",
                 statusCode: HttpStatusCode.UnprocessableEntity,
                 subStatusCode: DataApiBuilderException.SubStatusCodes.ConfigValidationError);
         }
 
-        // we will set them up with default values
-        _dataSourceNameToDataSource = new Dictionary<string, DataSource>
-        {
-            { this.DefaultDataSourceName, this.DataSource }
-        };
+        // Initialize data source dictionary - may be empty if parent relies solely on data-source-files
+        _dataSourceNameToDataSource = this.DataSource is not null
+            ? new Dictionary<string, DataSource> { { this.DefaultDataSourceName, this.DataSource } }
+            : new Dictionary<string, DataSource>();
 
         _entityNameToDataSourceName = new Dictionary<string, string>();
-        if (Entities is null)
+
+        if (Entities is null && !hasDataSourceFiles)
         {
             throw new DataApiBuilderException(
                 message: "entities is a mandatory property in DAB Config",
                 statusCode: HttpStatusCode.UnprocessableEntity,
                 subStatusCode: DataApiBuilderException.SubStatusCodes.ConfigValidationError);
         }
 
-        foreach (KeyValuePair<string, Entity> entity in Entities)
+        if (Entities is null)
+        {
+            this.Entities = new RuntimeEntities(new Dictionary<string, Entity>());
+        }
+
+        foreach (KeyValuePair<string, Entity> entity in this.Entities)
         {
             _entityNameToDataSourceName.TryAdd(entity.Key, this.DefaultDataSourceName);
         }
 
         // Process data source and entities information for each database in multiple database scenario.
         this.DataSourceFiles = DataSourceFiles;
 
-        if (DataSourceFiles is not null && DataSourceFiles.SourceFiles is not null)
+        if (hasDataSourceFiles)
         {
-            IEnumerable<KeyValuePair<string, Entity>> allEntities = Entities.AsEnumerable();
+            IEnumerable<KeyValuePair<string, Entity>> allEntities = this.Entities.AsEnumerable();
             // Iterate through all the datasource files and load the config.
             IFileSystem fileSystem = new FileSystem();
             // This loader is not used as a part of hot reload and therefore does not need a handler.
             FileSystemRuntimeConfigLoader loader = new(fileSystem, handler: null);
 
-            foreach (string dataSourceFile in DataSourceFiles.SourceFiles)
+            foreach (string dataSourceFile in DataSourceFiles!.SourceFiles!)
             {
                 // Use default replacement settings for environment variable replacement
                 DeserializationVariableReplacementSettings replacementSettings = new(azureKeyVaultOptions: null, doReplaceEnvVar: true, doReplaceAkvVar: true);
@@ -320,6 +327,13 @@ public RuntimeConfig(
                 {
                     try
                     {
+                        // If parent has no DataSource, adopt first child's DataSource as the default.
+                        if (this.DataSource is null && config.DataSource is not null)
+                        {
+                            this.DataSource = config.DataSource;
+                            _dataSourceNameToDataSource[this.DefaultDataSourceName] = this.DataSource;
+                        }
+
                         _dataSourceNameToDataSource = _dataSourceNameToDataSource.Concat(config._dataSourceNameToDataSource).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
                         _entityNameToDataSourceName = _entityNameToDataSourceName.Concat(config._entityNameToDataSourceName).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
                         allEntities = allEntities.Concat(config.Entities.AsEnumerable());
@@ -339,6 +353,15 @@ public RuntimeConfig(
             this.Entities = new RuntimeEntities(allEntities.ToDictionary(x => x.Key, x => x.Value));
         }
 
+        // Final validation: ensure at least one data source exists after loading all children
+        if (this.DataSource is null)
+        {
+            throw new DataApiBuilderException(
+                message: "data-source is a mandatory property in DAB Config. When using data-source-files, at least one child config must contain a valid data-source.",
+                statusCode: HttpStatusCode.UnprocessableEntity,
+                subStatusCode: DataApiBuilderException.SubStatusCodes.ConfigValidationError);
+        }
+
         SetupDataSourcesUsed();
 
     }

src/Service.Tests/Configuration/RuntimeConfigLoaderTests.cs

@@ -101,4 +101,51 @@ public async Task FailLoadMultiDataSourceConfigDuplicateEntities(string configPa
         Assert.IsTrue(error.StartsWith("Deserialization of the configuration file failed during a post-processing step."));
         Assert.IsTrue(error.Contains("An item with the same key has already been added."));
     }
+
+    /// <summary>
+    /// Test validates that when parent config has no data-source but has data-source-files,
+    /// the config loads correctly using the first child's data-source as the default.
+    /// Regression test for: https://github.com/Azure/data-api-builder/issues/2979
+    /// </summary>
+    [DataTestMethod]
+    [DataRow(new string[] { "Multidab-config.MsSql.json", "Multidab-config.MySql.json", "Multidab-config.PostgreSql.json" })]
+    public void CanLoadMultiSourceConfigWithoutParentDataSource(IEnumerable<string> dataSourceFiles)
+    {
+        // Create a parent config with NO data-source, only data-source-files and runtime
+        string parentConfig = @"{
+  ""$schema"": ""https://github.com/Azure/data-api-builder/releases/download/vmajor.minor.patch/dab.draft.schema.json"",
+  ""data-source-files"": [" + string.Join(",", dataSourceFiles.Select(f => $"\"{f}\"")) + @"],
+  ""runtime"": {
+    ""rest"": {
+      ""enabled"": true,
+      ""path"": ""/api""
+    },
+    ""graphql"": {
+      ""enabled"": true,
+      ""path"": ""/graphql""
+    },
+    ""host"": {
+      ""mode"": ""development""
+    }
+  }
+}";
+
+        IFileSystem fs = new MockFileSystem(new Dictionary<string, MockFileData>()
+        {
+            { "dab-config.json", new MockFileData(parentConfig) }
+        });
+
+        FileSystemRuntimeConfigLoader loader = new(fs);
+
+        Assert.IsTrue(loader.TryLoadConfig("dab-config.json", out RuntimeConfig runtimeConfig), "Should successfully load config with data-source-files only");
+
+        // Verify: 1 default (adopted from first child) + 3 from children = 4
+        Assert.AreEqual(4, runtimeConfig.ListAllDataSources().Count(), "Should have 4 data sources (1 default + 3 from children)");
+        Assert.IsTrue(runtimeConfig.SqlDataSourceUsed, "Should have Sql data source");
+
+        // First child's data source becomes the parent default
+        Assert.AreEqual(DatabaseType.MSSQL, runtimeConfig.DataSource.DatabaseType, "Default datasource should be from first child file (MsSql)");
+
+        Assert.IsTrue(runtimeConfig.Entities.Any(), "Should have entities from child configs");
+    }
 }