Enable or Disable Multiple Create operation based on feature flag value (#2116)

## Why make this change?

- Closes #1951
- PR #1983,
#2103 add CLI options to
enable or disable multiple mutation/multiple create operation through
CLI. With the changes introduced in the mentioned PRs, the configuration
properties successfully gets written to the config file. Also, during
deserialization, the properties are read and the
`MultipleMutationOptions`, `MultipleCreateOptions`,
`GraphQLRuntimeOptions` objects are created accordingly.
- The above-mentioned PRs do not introduce any change in DAB engine
behavior depending on the configuration property values.
- This PR introduces changes to read these fields and enable/disable
multiple create operation depending on whether the feature is
enabled/disabled through the config file. This is achieved by
introducing behavior changes in the schema generation.

## What is this change?
- This PR builds on top of a) Schema generation PR
#1902 b) Rename
nested-create to multiple create PR
#2103
- When multiple create operation is disabled, 
> i) Fields belonging to the related entities are not created in the
input object type are not created.
> ii) Many type multiple create mutation nodes (ex: `createbooks`,
`createpeople_multiple` ) are not created.
> iii) ReferencingField directive is not applied on relationship fields,
so they continue to remain required fields for the create mutation
operation.
> iv) Entities for linking objects are not created as they are relevant
only in the context of multiple create operations.

## How was this tested?

- [x] Unit Tests and Integration Tests 
- [x] Manual Tests 

**Note:** At the moment, multiple create operation is disabled in the
config file generated for integration tests. This is because of the plan
to merge in the Schema generation, AuthZ/N branches separately to the
main branch. With just these 2 PRs, a multiple create operation will
fail, hence, the disabling multiple create operation. At the moment,
tests that perform validations specific to multiple create feature
enable it by i) updating the runtime object (or) ii) creating a custom
config in which the operation is enabled.

## Sample Request(s)

### When Multiple Create operation is enabled - MsSQL

#### Related entity fields are created in the input object type

![image](https://github.com/Azure/data-api-builder/assets/11196553/7a3a8bbe-2742-43e0-98d7-9412ed05db33)

#### Multiple type create operation is created in addition to point
create operation

![image](https://github.com/Azure/data-api-builder/assets/11196553/c6513d9a-5b49-44cc-8fcc-1ed1f44f5f58)


#### Querying related entities continue to work successfully

![image](https://github.com/Azure/data-api-builder/assets/11196553/4c1a61b8-0cbb-4a1e-afaa-1849d710be27)



### When Multiple Create operation is disabled - MsSQL

#### Only fields belonging to the given entity are created in the input
object type

![image](https://github.com/Azure/data-api-builder/assets/11196553/a3b6beb2-7245-4345-ba13-29d8905d859e)

#### Multiple type create operation is not created


### When Multiple Create operation is enabled - Other relational
database types

#### Only fields belonging to the given entity are created in the input
object type

![image](https://github.com/Azure/data-api-builder/assets/11196553/b2a4f7f6-b121-410d-806d-8c5772253080)

#### Multiple type create operation is not created

---------

Co-authored-by: Ayush Agarwal <[email protected]>

Author: severussundar

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>