Enable or Disable Multiple Create operation based on feature flag value

src/Config/ObjectModel/MultipleCreateSupportingDatabaseType.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Azure.DataApiBuilder.Config.ObjectModel
+{
+    public enum MultipleCreateSupportingDatabaseType
+    {
+        MSSQL
+    }
+}

src/Config/ObjectModel/RuntimeConfig.cs

@@ -453,4 +453,22 @@ public static bool IsHotReloadable()
         // always return false while hot reload is not an available feature.
         return false;
     }
+
+    /// <summary>
+    /// Helper method to check if multiple create option is supported and enabled.
+    /// 
+    /// Returns true when
+    /// 1. Multiple create operation is supported by the database type and
+    /// 2. Multiple create operation is enabled in the runtime config.
+    /// 
+    /// </summary>
+    public bool IsMultipleCreateOperationEnabled()
+    {
+        return Enum.GetNames(typeof(MultipleCreateSupportingDatabaseType)).Any(x => x.Equals(DataSource.DatabaseType.ToString(), StringComparison.OrdinalIgnoreCase)) &&
+               (Runtime is not null &&
+               Runtime.GraphQL is not null &&
+               Runtime.GraphQL.MultipleMutationOptions is not null &&
+               Runtime.GraphQL.MultipleMutationOptions.MultipleCreateOptions is not null &&
+               Runtime.GraphQL.MultipleMutationOptions.MultipleCreateOptions.Enabled);
+    }
 }

src/Core/Services/GraphQLSchemaCreator.cs

@@ -42,6 +42,7 @@ public class GraphQLSchemaCreator
         private readonly RuntimeEntities _entities;
         private readonly IAuthorizationResolver _authorizationResolver;
         private readonly RuntimeConfigProvider _runtimeConfigProvider;
+        private bool _isMultipleCreateOperationEnabled;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="GraphQLSchemaCreator"/> class.
@@ -60,6 +61,7 @@ public GraphQLSchemaCreator(
         {
             RuntimeConfig runtimeConfig = runtimeConfigProvider.GetConfig();
 
+            _isMultipleCreateOperationEnabled = runtimeConfig.IsMultipleCreateOperationEnabled();
             _entities = runtimeConfig.Entities;
             _queryEngineFactory = queryEngineFactory;
             _mutationEngineFactory = mutationEngineFactory;
@@ -137,7 +139,7 @@ private ISchemaBuilder Parse(
             DocumentNode queryNode = QueryBuilder.Build(root, entityToDatabaseType, _entities, inputTypes, _authorizationResolver.EntityPermissionsMap, entityToDbObjects);
 
             // Generate the GraphQL mutations from the provided objects
-            DocumentNode mutationNode = MutationBuilder.Build(root, entityToDatabaseType, _entities, _authorizationResolver.EntityPermissionsMap, entityToDbObjects);
+            DocumentNode mutationNode = MutationBuilder.Build(root, entityToDatabaseType, _entities, _authorizationResolver.EntityPermissionsMap, entityToDbObjects, _isMultipleCreateOperationEnabled);
 
             return (queryNode, mutationNode);
         }
@@ -215,8 +217,7 @@ private DocumentNode GenerateSqlGraphQLObjects(RuntimeEntities entities, Diction
                             configEntity: entity,
                             entities: entities,
                             rolesAllowedForEntity: rolesAllowedForEntity,
-                            rolesAllowedForFields: rolesAllowedForFields
-                            );
+                            rolesAllowedForFields: rolesAllowedForFields);
 
                         if (databaseObject.SourceType is not EntitySourceType.StoredProcedure)
                         {
@@ -234,8 +235,13 @@ private DocumentNode GenerateSqlGraphQLObjects(RuntimeEntities entities, Diction
                 }
             }
 
-            // For all the fields in the object which hold a foreign key reference to any referenced entity, add a foreign key directive.
-            AddReferencingFieldDirective(entities, objectTypes);
+            // ReferencingFieldDirective is added to eventually mark the referencing fields in the input object types as optional. When multiple create operations are disabled
+            // the referencing fields should be required fields. Hence, ReferencingFieldDirective is added only when the multiple create operations are enabled.
+            if (_isMultipleCreateOperationEnabled)
+            {
+                // For all the fields in the object which hold a foreign key reference to any referenced entity, add a foreign key directive.
+                AddReferencingFieldDirective(entities, objectTypes);
+            }
 
             // Pass two - Add the arguments to the many-to-* relationship fields
             foreach ((string entityName, ObjectTypeDefinitionNode node) in objectTypes)
@@ -245,8 +251,13 @@ private DocumentNode GenerateSqlGraphQLObjects(RuntimeEntities entities, Diction
 
             // Create ObjectTypeDefinitionNode for linking entities. These object definitions are not exposed in the schema
             // but are used to generate the object definitions of directional linking entities for (source, target) and (target, source) entities.
-            Dictionary<string, ObjectTypeDefinitionNode> linkingObjectTypes = GenerateObjectDefinitionsForLinkingEntities();
-            GenerateSourceTargetLinkingObjectDefinitions(objectTypes, linkingObjectTypes);
+            // However, ObjectTypeDefinitionNode for linking entities are need only for multiple create operation. So, creating these only when multiple create operations are
+            // enabled.
+            if (_isMultipleCreateOperationEnabled)
+            {
+                Dictionary<string, ObjectTypeDefinitionNode> linkingObjectTypes = GenerateObjectDefinitionsForLinkingEntities();
+                GenerateSourceTargetLinkingObjectDefinitions(objectTypes, linkingObjectTypes);
+            }
 
             // Return a list of all the object types to be exposed in the schema.
             Dictionary<string, FieldDefinitionNode> fields = new();

src/Core/Services/MetadataProviders/MsSqlMetadataProvider.cs

@@ -29,6 +29,8 @@ namespace Azure.DataApiBuilder.Core.Services
     public class MsSqlMetadataProvider :
         SqlMetadataProvider<SqlConnection, SqlDataAdapter, SqlCommand>
     {
+        private RuntimeConfigProvider _runtimeConfigProvider;
+
         public MsSqlMetadataProvider(
             RuntimeConfigProvider runtimeConfigProvider,
             IAbstractQueryManagerFactory queryManagerFactory,
@@ -37,6 +39,7 @@ public MsSqlMetadataProvider(
             bool isValidateOnly = false)
             : base(runtimeConfigProvider, queryManagerFactory, logger, dataSourceName, isValidateOnly)
         {
+            _runtimeConfigProvider = runtimeConfigProvider;
         }
 
         public override string GetDefaultSchemaName()
@@ -219,7 +222,7 @@ protected override void PopulateMetadataForLinkingObject(
             string linkingObject,
             Dictionary<string, DatabaseObject> sourceObjects)
         {
-            if (!GraphQLUtils.DoesRelationalDBSupportMultipleCreate(GetDatabaseType()))
+            if (!_runtimeConfigProvider.GetConfig().IsMultipleCreateOperationEnabled())
             {
                 // Currently we have this same class instantiated for both MsSql and DwSql.
                 // This is a refactor we need to take care of in future.

src/Core/Services/MetadataProviders/SqlMetadataProvider.cs

@@ -755,16 +755,22 @@ private void ProcessRelationships(
                         referencedColumns: relationship.TargetFields,
                         relationshipData);
 
-                    // When a linking object is encountered for a database table, we will create a linking entity for the object.
-                    // Subsequently, we will also populate the Database object for the linking entity. This is used to infer
-                    // metadata about linking object needed to create GQL schema for multiple insertions.
-                    if (entity.Source.Type is EntitySourceType.Table)
+                    RuntimeConfig runtimeConfig = _runtimeConfigProvider.GetConfig();
+
+                    // Populating metadata for linking object is only required when multiple create operation is enabled and those database types that support multiple create operation.
+                    if (runtimeConfig.IsMultipleCreateOperationEnabled())
                     {
-                        PopulateMetadataForLinkingObject(
-                            entityName: entityName,
-                            targetEntityName: targetEntityName,
-                            linkingObject: relationship.LinkingObject,
-                            sourceObjects: sourceObjects);
+                        // When a linking object is encountered for a database table, we will create a linking entity for the object.
+                        // Subsequently, we will also populate the Database object for the linking entity. This is used to infer
+                        // metadata about linking object needed to create GQL schema for multiple insertions.
+                        if (entity.Source.Type is EntitySourceType.Table)
+                        {
+                            PopulateMetadataForLinkingObject(
+                                entityName: entityName,
+                                targetEntityName: targetEntityName,
+                                linkingObject: relationship.LinkingObject,
+                                sourceObjects: sourceObjects);
+                        }
                     }
                 }
                 else if (relationship.Cardinality == Cardinality.One)

src/Service.GraphQLBuilder/GraphQLUtils.cs

@@ -32,8 +32,6 @@ public static class GraphQLUtils
         // Delimiter used to separate linking entity prefix/source entity name/target entity name, in the name of a linking entity.
         private const string ENTITY_NAME_DELIMITER = "$";
 
-        public static HashSet<DatabaseType> RELATIONAL_DBS_SUPPORTING_MULTIPLE_CREATE = new() { DatabaseType.MSSQL };
-
         public static HashSet<DatabaseType> RELATIONAL_DBS = new() { DatabaseType.MSSQL, DatabaseType.MySQL,
             DatabaseType.DWSQL, DatabaseType.PostgreSQL, DatabaseType.CosmosDB_PostgreSQL };
 
@@ -72,14 +70,6 @@ public static bool IsBuiltInType(ITypeNode typeNode)
             return builtInTypes.Contains(name);
         }
 
-        /// <summary>
-        /// Helper method to evaluate whether DAB supports multiple create for a particular database type.
-        /// </summary>
-        public static bool DoesRelationalDBSupportMultipleCreate(DatabaseType databaseType)
-        {
-            return RELATIONAL_DBS_SUPPORTING_MULTIPLE_CREATE.Contains(databaseType);
-        }
-
         /// <summary>
         /// Helper method to evaluate whether database type represents a NoSQL database.
         /// </summary>