Merge branch 'main' into copilot/add-role-inheritance-permissions

Author: aaronburtle

src/Azure.DataApiBuilder.Mcp/BuiltInTools/CreateRecordTool.cs

@@ -124,17 +124,23 @@ public async Task<CallToolResult> ExecuteAsync(
                 }
 
                 JsonElement insertPayloadRoot = dataElement.Clone();
+
+                // Validate it's a table or view - stored procedures use execute_entity
+                if (dbObject.SourceType != EntitySourceType.Table && dbObject.SourceType != EntitySourceType.View)
+                {
+                    return McpResponseBuilder.BuildErrorResult(toolName, "InvalidEntity", $"Entity '{entityName}' is not a table or view. For stored procedures, use the execute_entity tool instead.", logger);
+                }
+
                 InsertRequestContext insertRequestContext = new(
                     entityName,
                     dbObject,
                     insertPayloadRoot,
                     EntityActionOperation.Insert);
 
-                RequestValidator requestValidator = serviceProvider.GetRequiredService<RequestValidator>();
-
-                // Only validate tables
+                // Only validate tables. For views, skip validation and let the database handle any errors.
                 if (dbObject.SourceType is EntitySourceType.Table)
                 {
+                    RequestValidator requestValidator = serviceProvider.GetRequiredService<RequestValidator>();
                     try
                     {
                         requestValidator.ValidateInsertRequestContext(insertRequestContext);
@@ -144,14 +150,6 @@ public async Task<CallToolResult> ExecuteAsync(
                         return McpResponseBuilder.BuildErrorResult(toolName, "ValidationFailed", $"Request validation failed: {ex.Message}", logger);
                     }
                 }
-                else
-                {
-                    return McpResponseBuilder.BuildErrorResult(
-                        toolName,
-                        "InvalidCreateTarget",
-                        "The create_record tool is only available for tables.",
-                        logger);
-                }
 
                 IMutationEngineFactory mutationEngineFactory = serviceProvider.GetRequiredService<IMutationEngineFactory>();
                 DatabaseType databaseType = sqlMetadataProvider.GetDatabaseType();

src/Azure.DataApiBuilder.Mcp/BuiltInTools/ReadRecordsTool.cs

@@ -158,6 +158,12 @@ public async Task<CallToolResult> ExecuteAsync(
                     return McpResponseBuilder.BuildErrorResult(toolName, "EntityNotFound", metadataError, logger);
                 }
 
+                // Validate it's a table or view
+                if (dbObject.SourceType != EntitySourceType.Table && dbObject.SourceType != EntitySourceType.View)
+                {
+                    return McpResponseBuilder.BuildErrorResult(toolName, "InvalidEntity", $"Entity '{entityName}' is not a table or view. For stored procedures, use the execute_entity tool instead.", logger);
+                }
+
                 // Authorization check in the existing entity
                 IAuthorizationResolver authResolver = serviceProvider.GetRequiredService<IAuthorizationResolver>();
                 IAuthorizationService authorizationService = serviceProvider.GetRequiredService<IAuthorizationService>();

src/Azure.DataApiBuilder.Mcp/BuiltInTools/UpdateRecordTool.cs

@@ -137,6 +137,12 @@ public async Task<CallToolResult> ExecuteAsync(
                     return McpResponseBuilder.BuildErrorResult(toolName, "EntityNotFound", metadataError, logger);
                 }
 
+                // Validate it's a table or view
+                if (dbObject.SourceType != EntitySourceType.Table && dbObject.SourceType != EntitySourceType.View)
+                {
+                    return McpResponseBuilder.BuildErrorResult(toolName, "InvalidEntity", $"Entity '{entityName}' is not a table or view. For stored procedures, use the execute_entity tool instead.", logger);
+                }
+
                 // 5) Authorization after we have a known entity
                 IHttpContextAccessor httpContextAccessor = serviceProvider.GetRequiredService<IHttpContextAccessor>();
                 HttpContext? httpContext = httpContextAccessor.HttpContext;

src/Service.Tests/Mcp/EntityLevelDmlToolConfigurationTests.cs

@@ -7,9 +7,12 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Azure.DataApiBuilder.Auth;
+using Azure.DataApiBuilder.Config.DatabasePrimitives;
 using Azure.DataApiBuilder.Config.ObjectModel;
 using Azure.DataApiBuilder.Core.Authorization;
 using Azure.DataApiBuilder.Core.Configurations;
+using Azure.DataApiBuilder.Core.Services;
+using Azure.DataApiBuilder.Core.Services.MetadataProviders;
 using Azure.DataApiBuilder.Mcp.BuiltInTools;
 using Azure.DataApiBuilder.Mcp.Model;
 using Microsoft.AspNetCore.Http;
@@ -188,8 +191,74 @@ public async Task DynamicCustomTool_RespectsCustomToolDisabled()
             AssertToolDisabledError(content, "Custom tool is disabled for entity 'GetBook'");
         }
 
+        #region View Support Tests
+
+        /// <summary>
+        /// Data-driven test to verify all DML tools allow both table and view entities.
+        /// This is critical for scenarios like vector data type support, where users must:
+        /// - Create a view that omits unsupported columns (e.g., vector columns)
+        /// - Perform DML operations against that view
+        /// </summary>
+        /// <param name="toolType">The tool type to test.</param>
+        /// <param name="sourceType">The entity source type (Table or View).</param>
+        /// <param name="entityName">The entity name to use.</param>
+        /// <param name="jsonArguments">The JSON arguments for the tool.</param>
+        [DataTestMethod]
+        [DataRow("CreateRecord", "Table", "{\"entity\": \"Book\", \"data\": {\"id\": 1, \"title\": \"Test\"}}", DisplayName = "CreateRecord allows Table")]
+        [DataRow("CreateRecord", "View", "{\"entity\": \"BookView\", \"data\": {\"id\": 1, \"title\": \"Test\"}}", DisplayName = "CreateRecord allows View")]
+        [DataRow("ReadRecords", "Table", "{\"entity\": \"Book\"}", DisplayName = "ReadRecords allows Table")]
+        [DataRow("ReadRecords", "View", "{\"entity\": \"BookView\"}", DisplayName = "ReadRecords allows View")]
+        [DataRow("UpdateRecord", "Table", "{\"entity\": \"Book\", \"keys\": {\"id\": 1}, \"fields\": {\"title\": \"Updated\"}}", DisplayName = "UpdateRecord allows Table")]
+        [DataRow("UpdateRecord", "View", "{\"entity\": \"BookView\", \"keys\": {\"id\": 1}, \"fields\": {\"title\": \"Updated\"}}", DisplayName = "UpdateRecord allows View")]
+        [DataRow("DeleteRecord", "Table", "{\"entity\": \"Book\", \"keys\": {\"id\": 1}}", DisplayName = "DeleteRecord allows Table")]
+        [DataRow("DeleteRecord", "View", "{\"entity\": \"BookView\", \"keys\": {\"id\": 1}}", DisplayName = "DeleteRecord allows View")]
+        public async Task DmlTool_AllowsTablesAndViews(string toolType, string sourceType, string jsonArguments)
+        {
+            // Arrange
+            RuntimeConfig config = sourceType == "View"
+                ? CreateConfigWithViewEntity()
+                : CreateConfigWithDmlToolEnabledEntity();
+            IServiceProvider serviceProvider = CreateServiceProvider(config);
+            IMcpTool tool = CreateTool(toolType);
+
+            JsonDocument arguments = JsonDocument.Parse(jsonArguments);
+
+            // Act
+            CallToolResult result = await tool.ExecuteAsync(arguments, serviceProvider, CancellationToken.None);
+
+            // Assert - Should NOT be a source type blocking error (InvalidEntity)
+            // Other errors like missing metadata are acceptable since we're testing source type validation
+            if (result.IsError == true)
+            {
+                JsonElement content = ParseResultContent(result);
+
+                if (content.TryGetProperty("error", out JsonElement error) &&
+                    error.TryGetProperty("type", out JsonElement errorType))
+                {
+                    string errorTypeValue = errorType.GetString() ?? string.Empty;
+
+                    // This error type indicates the tool is blocking based on source type
+                    Assert.AreNotEqual("InvalidEntity", errorTypeValue,
+                        $"{sourceType} entities should not be blocked with InvalidEntity");
+                }
+            }
+        }
+
+        #endregion
+
         #region Helper Methods
 
+        /// <summary>
+        /// Helper method to parse the JSON content from a CallToolResult without re-executing the tool.
+        /// </summary>
+        /// <param name="result">The result from executing an MCP tool.</param>
+        /// <returns>The parsed JsonElement from the result's content.</returns>
+        private static JsonElement ParseResultContent(CallToolResult result)
+        {
+            TextContentBlock firstContent = (TextContentBlock)result.Content[0];
+            return JsonDocument.Parse(firstContent.Text).RootElement;
+        }
+
         /// <summary>
         /// Helper method to execute an MCP tool and return the parsed JsonElement from the result.
         /// </summary>
@@ -200,8 +269,7 @@ public async Task DynamicCustomTool_RespectsCustomToolDisabled()
         private static async Task<JsonElement> RunToolAsync(IMcpTool tool, JsonDocument arguments, IServiceProvider serviceProvider)
         {
             CallToolResult result = await tool.ExecuteAsync(arguments, serviceProvider, CancellationToken.None);
-            TextContentBlock firstContent = (TextContentBlock)result.Content[0];
-            return JsonDocument.Parse(firstContent.Text).RootElement;
+            return ParseResultContent(result);
         }
 
         /// <summary>
@@ -517,8 +585,63 @@ private static RuntimeConfig CreateConfigWithRuntimeDisabledButEntityEnabled()
             );
         }
 
+        /// <summary>
+        /// Creates a runtime config with a view entity.
+        /// This is the key scenario for vector data type support.
+        /// </summary>
+        private static RuntimeConfig CreateConfigWithViewEntity()
+        {
+            Dictionary<string, Entity> entities = new()
+            {
+                ["BookView"] = new Entity(
+                    Source: new EntitySource(
+                        Object: "dbo.vBooks",
+                        Type: EntitySourceType.View,
+                        Parameters: null,
+                        KeyFields: new[] { "id" }
+                    ),
+                    GraphQL: new("BookView", "BookViews"),
+                    Fields: null,
+                    Rest: new(Enabled: true),
+                    Permissions: new[] { new EntityPermission(Role: "anonymous", Actions: new[] {
+                        new EntityAction(Action: EntityActionOperation.Read, Fields: null, Policy: null),
+                        new EntityAction(Action: EntityActionOperation.Create, Fields: null, Policy: null),
+                        new EntityAction(Action: EntityActionOperation.Update, Fields: null, Policy: null),
+                        new EntityAction(Action: EntityActionOperation.Delete, Fields: null, Policy: null)
+                    }) },
+                    Mappings: null,
+                    Relationships: null,
+                    Mcp: new EntityMcpOptions(customToolEnabled: false, dmlToolsEnabled: true)
+                )
+            };
+
+            return new RuntimeConfig(
+                Schema: "test-schema",
+                DataSource: new DataSource(DatabaseType: DatabaseType.MSSQL, ConnectionString: "", Options: null),
+                Runtime: new(
+                    Rest: new(),
+                    GraphQL: new(),
+                    Mcp: new(
+                        Enabled: true,
+                        Path: "/mcp",
+                        DmlTools: new(
+                            describeEntities: true,
+                            readRecords: true,
+                            createRecord: true,
+                            updateRecord: true,
+                            deleteRecord: true,
+                            executeEntity: true
+                        )
+                    ),
+                    Host: new(Cors: null, Authentication: null, Mode: HostMode.Development)
+                ),
+                Entities: new(entities)
+            );
+        }
+
         /// <summary>
         /// Creates a service provider with mocked dependencies for testing MCP tools.
+        /// Includes metadata provider mocks so tests can reach source type validation.
         /// </summary>
         private static IServiceProvider CreateServiceProvider(RuntimeConfig config)
         {
@@ -540,6 +663,54 @@ private static IServiceProvider CreateServiceProvider(RuntimeConfig config)
             mockHttpContextAccessor.Setup(x => x.HttpContext).Returns(mockHttpContext.Object);
             services.AddSingleton(mockHttpContextAccessor.Object);
 
+            // Add metadata provider mocks so tests can reach source type validation.
+            // This is required for DmlTool_AllowsTablesAndViews to actually test the source type behavior.
+            Mock<ISqlMetadataProvider> mockSqlMetadataProvider = new();
+            Dictionary<string, DatabaseObject> entityToDatabaseObject = new();
+
+            // Add database objects for each entity in the config
+            if (config.Entities != null)
+            {
+                foreach (KeyValuePair<string, Entity> kvp in config.Entities)
+                {
+                    string entityName = kvp.Key;
+                    Entity entity = kvp.Value;
+                    EntitySourceType sourceType = entity.Source.Type ?? EntitySourceType.Table;
+
+                    DatabaseObject dbObject;
+                    if (sourceType == EntitySourceType.View)
+                    {
+                        dbObject = new DatabaseView("dbo", entity.Source.Object)
+                        {
+                            SourceType = EntitySourceType.View
+                        };
+                    }
+                    else if (sourceType == EntitySourceType.StoredProcedure)
+                    {
+                        dbObject = new DatabaseStoredProcedure("dbo", entity.Source.Object)
+                        {
+                            SourceType = EntitySourceType.StoredProcedure
+                        };
+                    }
+                    else
+                    {
+                        dbObject = new DatabaseTable("dbo", entity.Source.Object)
+                        {
+                            SourceType = EntitySourceType.Table
+                        };
+                    }
+
+                    entityToDatabaseObject[entityName] = dbObject;
+                }
+            }
+
+            mockSqlMetadataProvider.Setup(x => x.EntityToDatabaseObject).Returns(entityToDatabaseObject);
+            mockSqlMetadataProvider.Setup(x => x.GetDatabaseType()).Returns(DatabaseType.MSSQL);
+
+            Mock<IMetadataProviderFactory> mockMetadataProviderFactory = new();
+            mockMetadataProviderFactory.Setup(x => x.GetMetadataProvider(It.IsAny<string>())).Returns(mockSqlMetadataProvider.Object);
+            services.AddSingleton(mockMetadataProviderFactory.Object);
+
             services.AddLogging();
 
             return services.BuildServiceProvider();