Create Entities in-memory from Autoentities

src/Cli.Tests/ConfigGeneratorTests.cs

@@ -178,6 +178,7 @@ public void TestSpecialCharactersInConnectionString()
                   ""mode"": ""production""
                   }
               },
+              ""autoentities"": {},
               ""entities"": {}
             }");
 

src/Cli.Tests/ModuleInitializer.cs

@@ -107,6 +107,8 @@ public static void Init()
         VerifierSettings.IgnoreMember<GraphQLRuntimeOptions>(options => options.FeatureFlags);
         // Ignore the JSON schema path as that's unimportant from a test standpoint.
         VerifierSettings.IgnoreMember<RuntimeConfig>(config => config.Schema);
+        // Ignore the JSON schema path as that's unimportant from a test standpoint.
+        VerifierSettings.IgnoreMember<RuntimeConfig>(config => config.Autoentities);
         // Ignore the message as that's not serialized in our config file anyway.
         VerifierSettings.IgnoreMember<DataSource>(dataSource => dataSource.DatabaseTypeNotSupportedMessage);
         // Ignore DefaultDataSourceName as that's not serialized in our config file.

src/Cli.Tests/TestHelper.cs

@@ -1302,6 +1302,7 @@ public static string GenerateConfigWithGivenDepthLimit(string? depthLimitJson =
                     }}
                 }}
             }},
+            ""autoentities"": {{}},
             ""entities"": {{}}";
 
             return $"{{{SAMPLE_SCHEMA_DATA_SOURCE},{runtimeSection}}}";

src/Config/Converters/RuntimeAutoentitiesConverter.cs

@@ -29,7 +29,7 @@ class RuntimeAutoentitiesConverter : JsonConverter<RuntimeAutoentities>
     public override void Write(Utf8JsonWriter writer, RuntimeAutoentities value, JsonSerializerOptions options)
     {
         writer.WriteStartObject();
-        foreach ((string key, Autoentity autoEntity) in value.AutoEntities)
+        foreach ((string key, Autoentity autoEntity) in value.Autoentities)
         {
             writer.WritePropertyName(key);
             JsonSerializer.Serialize(writer, autoEntity, options);

src/Config/ObjectModel/RuntimeAutoentities.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Collections;
 using System.Text.Json.Serialization;
 using Azure.DataApiBuilder.Config.Converters;
 
@@ -10,19 +11,29 @@ namespace Azure.DataApiBuilder.Config.ObjectModel;
 /// Represents a collection of <see cref="Autoentity"/> available from the RuntimeConfig.
 /// </summary>
 [JsonConverter(typeof(RuntimeAutoentitiesConverter))]
-public record RuntimeAutoentities
+public record RuntimeAutoentities : IEnumerable<KeyValuePair<string, Autoentity>>
 {
     /// <summary>
     /// The collection of <see cref="Autoentity"/> available from the RuntimeConfig.
     /// </summary>
-    public IReadOnlyDictionary<string, Autoentity> AutoEntities { get; init; }
+    public IReadOnlyDictionary<string, Autoentity> Autoentities { get; init; }
 
     /// <summary>
     /// Creates a new instance of the <see cref="RuntimeAutoentities"/> class using a collection of entities.
     /// </summary>
-    /// <param name="autoEntities">The collection of auto-entities to map to RuntimeAutoentities.</param>
-    public RuntimeAutoentities(IReadOnlyDictionary<string, Autoentity> autoEntities)
+    /// <param name="autoentities">The collection of auto-entities to map to RuntimeAutoentities.</param>
+    public RuntimeAutoentities(IReadOnlyDictionary<string, Autoentity> autoentities)
     {
-        AutoEntities = autoEntities;
+        Autoentities = autoentities;
+    }
+
+    public IEnumerator<KeyValuePair<string, Autoentity>> GetEnumerator()
+    {
+        return Autoentities.GetEnumerator();
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        return GetEnumerator();
     }
 }

src/Config/ObjectModel/RuntimeConfig.cs

@@ -25,7 +25,7 @@ public record RuntimeConfig
     [JsonPropertyName("azure-key-vault")]
     public AzureKeyVaultOptions? AzureKeyVault { get; init; }
 
-    public RuntimeAutoentities? Autoentities { get; init; }
+    public RuntimeAutoentities Autoentities { get; init; }
 
     public virtual RuntimeEntities Entities { get; init; }
 
@@ -216,6 +216,8 @@ Runtime.GraphQL.FeatureFlags is not null &&
 
     private Dictionary<string, string> _entityNameToDataSourceName = new();
 
+    private Dictionary<string, string> _autoentityNameToDataSourceName = new();
+
     private Dictionary<string, string> _entityPathNameToEntityName = new();
 
     /// <summary>
@@ -245,6 +247,21 @@ public bool TryGetEntityNameFromPath(string entityPathName, [NotNullWhen(true)]
         return _entityPathNameToEntityName.TryGetValue(entityPathName, out entityName);
     }
 
+    public bool TryAddEntityNameToDataSourceName(string entityName)
+    {
+        return _entityNameToDataSourceName.TryAdd(entityName, this.DefaultDataSourceName);
+    }
+
+    public bool TryAddGeneratedAutoentityNameToDataSourceName(string entityName, string autoEntityDefinition)
+    {
+        if (_autoentityNameToDataSourceName.TryGetValue(autoEntityDefinition, out string? dataSourceName))
+        {
+            return _entityNameToDataSourceName.TryAdd(entityName, dataSourceName);
+        }
+
+        return false;
+    }
+
     /// <summary>
     /// Constructor for runtimeConfig.
     /// To be used when setting up from cli json scenario.
@@ -268,8 +285,8 @@ public RuntimeConfig(
         this.DataSource = DataSource;
         this.Runtime = Runtime;
         this.AzureKeyVault = AzureKeyVault;
-        this.Entities = Entities;
-        this.Autoentities = Autoentities;
+        this.Entities = Entities ?? new RuntimeEntities(new Dictionary<string, Entity>());
+        this.Autoentities = Autoentities ?? new RuntimeAutoentities(new Dictionary<string, Autoentity>());
         this.DefaultDataSourceName = Guid.NewGuid().ToString();
 
         if (this.DataSource is null)
@@ -287,25 +304,38 @@ public RuntimeConfig(
         };
 
         _entityNameToDataSourceName = new Dictionary<string, string>();
-        if (Entities is null)
+        if (Entities is null && this.Entities.Entities.Count == 0 &&
+            Autoentities is null && this.Autoentities.Autoentities.Count == 0)
         {
             throw new DataApiBuilderException(
-                message: "entities is a mandatory property in DAB Config",
+                message: "Configuration file should contain either at least the entities or autoentities property",
                 statusCode: HttpStatusCode.UnprocessableEntity,
                 subStatusCode: DataApiBuilderException.SubStatusCodes.ConfigValidationError);
         }
 
-        foreach (KeyValuePair<string, Entity> entity in Entities)
+        if (Entities is not null)
+        {
+            foreach (KeyValuePair<string, Entity> entity in Entities)
+            {
+                _entityNameToDataSourceName.TryAdd(entity.Key, this.DefaultDataSourceName);
+            }
+        }
+
+        if (Autoentities is not null)
         {
-            _entityNameToDataSourceName.TryAdd(entity.Key, this.DefaultDataSourceName);
+            foreach (KeyValuePair<string, Autoentity> autoentity in Autoentities)
+            {
+                _autoentityNameToDataSourceName.TryAdd(autoentity.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)
         {
-            IEnumerable<KeyValuePair<string, Entity>> allEntities = Entities.AsEnumerable();
+            IEnumerable<KeyValuePair<string, Entity>>? allEntities = Entities?.AsEnumerable();
+            IEnumerable<KeyValuePair<string, Autoentity>>? allAutoentities = Autoentities?.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.
@@ -322,7 +352,9 @@ public RuntimeConfig(
                     {
                         _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());
+                        _autoentityNameToDataSourceName = _autoentityNameToDataSourceName.Concat(config._autoentityNameToDataSourceName).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
+                        allEntities = allEntities?.Concat(config.Entities.AsEnumerable());
+                        allAutoentities = allAutoentities?.Concat(config.Autoentities.AsEnumerable());
                     }
                     catch (Exception e)
                     {
@@ -336,7 +368,8 @@ public RuntimeConfig(
                 }
             }
 
-            this.Entities = new RuntimeEntities(allEntities.ToDictionary(x => x.Key, x => x.Value));
+            this.Entities = new RuntimeEntities(allEntities != null ? allEntities.ToDictionary(x => x.Key, x => x.Value) : new Dictionary<string, Entity>());
+            this.Autoentities = new RuntimeAutoentities(allAutoentities != null ? allAutoentities.ToDictionary(x => x.Key, x => x.Value) : new Dictionary<string, Autoentity>());
         }
 
         SetupDataSourcesUsed();
@@ -351,17 +384,19 @@ public RuntimeConfig(
     /// <param name="DataSource">Default datasource.</param>
     /// <param name="Runtime">Runtime settings.</param>
     /// <param name="Entities">Entities</param>
+    /// <param name="Autoentities">Autoentities</param>
     /// <param name="DataSourceFiles">List of datasource files for multiple db scenario.Null for single db scenario.
     /// <param name="DefaultDataSourceName">DefaultDataSourceName to maintain backward compatibility.</param>
     /// <param name="DataSourceNameToDataSource">Dictionary mapping datasourceName to datasource object.</param>
     /// <param name="EntityNameToDataSourceName">Dictionary mapping entityName to datasourceName.</param>
     /// <param name="DataSourceFiles">Datasource files which represent list of child runtimeconfigs for multi-db scenario.</param>
-    public RuntimeConfig(string Schema, DataSource DataSource, RuntimeOptions Runtime, RuntimeEntities Entities, string DefaultDataSourceName, Dictionary<string, DataSource> DataSourceNameToDataSource, Dictionary<string, string> EntityNameToDataSourceName, DataSourceFiles? DataSourceFiles = null, AzureKeyVaultOptions? AzureKeyVault = null)
+    public RuntimeConfig(string Schema, DataSource DataSource, RuntimeOptions Runtime, RuntimeEntities Entities, string DefaultDataSourceName, Dictionary<string, DataSource> DataSourceNameToDataSource, Dictionary<string, string> EntityNameToDataSourceName, DataSourceFiles? DataSourceFiles = null, AzureKeyVaultOptions? AzureKeyVault = null, RuntimeAutoentities? Autoentities = null)
     {
         this.Schema = Schema;
         this.DataSource = DataSource;
         this.Runtime = Runtime;
         this.Entities = Entities;
+        this.Autoentities = Autoentities ?? new RuntimeAutoentities(new Dictionary<string, Autoentity>());
         this.DefaultDataSourceName = DefaultDataSourceName;
         _dataSourceNameToDataSource = DataSourceNameToDataSource;
         _entityNameToDataSourceName = EntityNameToDataSourceName;
@@ -451,6 +486,24 @@ public DataSource GetDataSourceFromEntityName(string entityName)
         return _dataSourceNameToDataSource[_entityNameToDataSourceName[entityName]];
     }
 
+    /// <summary>
+    /// Gets datasourceName from AutoentityNameToDatasourceName dictionary.
+    /// </summary>
+    /// <param name="autoentityName">autoentityName</param>
+    /// <returns>DataSourceName</returns>
+    public string GetDataSourceNameFromAutoentityName(string autoentityName)
+    {
+        if (!_autoentityNameToDataSourceName.TryGetValue(autoentityName, out string? autoentityDataSource))
+        {
+            throw new DataApiBuilderException(
+                message: $"{autoentityName} is not a valid autoentity.",
+                statusCode: HttpStatusCode.NotFound,
+                subStatusCode: DataApiBuilderException.SubStatusCodes.EntityNotFound);
+        }
+
+        return autoentityDataSource;
+    }
+
     /// <summary>
     /// Validates if datasource is present in runtimeConfig.
     /// </summary>

src/Config/RuntimeConfigLoader.cs

@@ -499,4 +499,9 @@ public void InsertWantedChangesInProductionMode()
             RuntimeConfig = runtimeConfigCopy;
         }
     }
+
+    public void EditRuntimeConfig(RuntimeConfig newRuntimeConfig)
+    {
+        RuntimeConfig = newRuntimeConfig;
+    }
 }

src/Core/Configurations/RuntimeConfigProvider.cs

@@ -411,4 +411,19 @@ private static RuntimeConfig HandleCosmosNoSqlConfiguration(string? schema, Runt
 
         return runtimeConfig;
     }
+
+    public void AddMergedEntitiesToConfig(Dictionary<string, Entity> newEntities)
+    {
+        Dictionary<string, Entity> entities = new(_configLoader.RuntimeConfig!.Entities);
+        foreach ((string name, Entity entity) in newEntities)
+        {
+            entities.Add(name, entity);
+        }
+
+        RuntimeConfig newRuntimeConfig = _configLoader.RuntimeConfig! with
+        {
+            Entities = new(entities)
+        };
+        _configLoader.EditRuntimeConfig(newRuntimeConfig);
+    }
 }

src/Core/Services/MetadataProviders/MsSqlMetadataProvider.cs

@@ -292,9 +292,93 @@ private bool TryResolveDbType(string sqlDbTypeName, out DbType dbType)
         }
 
         /// <inheritdoc/>
-        protected override async Task GenerateAutoentitiesIntoEntities()
+        protected override async Task GenerateAutoentitiesIntoEntities(IReadOnlyDictionary<string, Autoentity>? autoentities)
         {
-            await Task.CompletedTask;
+            if (autoentities is null)
+            {
+                return;
+            }
+
+            RuntimeConfig runtimeConfig = _runtimeConfigProvider.GetConfig();
+            Dictionary<string, Entity> entities = new();
+            foreach ((string autoentityName, Autoentity autoentity) in autoentities)
+            {
+                int addedEntities = 0;
+                JsonArray? resultArray = await QueryAutoentitiesAsync(autoentity);
+                if (resultArray is null)
+                {
+                    continue;
+                }
+
+                foreach (JsonObject? resultObject in resultArray)
+                {
+                    if (resultObject is null)
+                    {
+                        throw new DataApiBuilderException(
+                            message: $"Cannot create new entity from autoentity pattern due to an internal error.",
+                            statusCode: HttpStatusCode.InternalServerError,
+                            subStatusCode: DataApiBuilderException.SubStatusCodes.ErrorInInitialization);
+                    }
+
+                    // Extract the entity name, schema, and database object name from the query result.
+                    // The SQL query returns these values with placeholders already replaced.
+                    string? entityName = resultObject["entity_name"]?.ToString();
+                    string? objectName = resultObject["object"]?.ToString();
+                    string? schemaName = resultObject["schema"]?.ToString();
+
+                    if (string.IsNullOrWhiteSpace(entityName) || string.IsNullOrWhiteSpace(objectName) || string.IsNullOrWhiteSpace(schemaName))
+                    {
+                        _logger.LogError("Skipping autoentity generation: entity_name or object is null or empty for autoentity pattern '{AutoentityName}'.", autoentityName);
+                        continue;
+                    }
+
+                    // Create the entity using the template settings and permissions from the autoentity configuration.
+                    // Currently the source type is always Table for auto-generated entities from database objects.
+                    Entity generatedEntity = new(
+                        Source: new EntitySource(
+                            Object: objectName,
+                            Type: EntitySourceType.Table,
+                            Parameters: null,
+                            KeyFields: null),
+                        GraphQL: autoentity.Template.GraphQL,
+                        Rest: autoentity.Template.Rest,
+                        Mcp: autoentity.Template.Mcp,
+                        Permissions: autoentity.Permissions,
+                        Cache: autoentity.Template.Cache,
+                        Health: autoentity.Template.Health,
+                        Fields: null,
+                        Relationships: null,
+                        Mappings: new());
+
+                    // Add the generated entity to the linking entities dictionary.
+                    // This allows the entity to be processed later during metadata population.
+                    if (!entities.TryAdd(entityName, generatedEntity) || !runtimeConfig.TryAddGeneratedAutoentityNameToDataSourceName(entityName, autoentityName))
+                    {
+                        throw new DataApiBuilderException(
+                            message: $"Entity with name '{entityName}' already exists. Cannot create new entity from autoentity pattern with definition-name '{autoentityName}'.",
+                            statusCode: HttpStatusCode.BadRequest,
+                            subStatusCode: DataApiBuilderException.SubStatusCodes.ErrorInInitialization);
+                    }
+
+                    if (runtimeConfig.IsRestEnabled)
+                    {
+                        _logger.LogInformation("[{entity}] REST path: {globalRestPath}/{entityRestPath}", entityName, runtimeConfig.RestPath, entityName);
+                    }
+                    else
+                    {
+                        _logger.LogInformation(message: "REST calls are disabled for the entity: {entity}", entityName);
+                    }
+
+                    addedEntities++;
+                }
+
+                if (addedEntities == 0)
+                {
+                    _logger.LogWarning($"No new entities were generated from the autoentity {autoentityName} defined in the configuration.");
+                }
+            }
+
+            _runtimeConfigProvider.AddMergedEntitiesToConfig(entities);
         }
 
         public async Task<JsonArray?> QueryAutoentitiesAsync(Autoentity autoentity)