Cosmos DB: Adds circular reference check for entities in graphQL schema (#2192)

## Why make this change?
Today, if graphQL schema has circular reference of entities, DAB won't
be able to load the schema and die with stackoverflow exception when it
tries to traverse the schema.
With JSON data, it can get very complicated to handle all the scenarios
with circular reference.

## What is this change?
Adding a proper exception during the load, if DAB identifies that schema
has circular reference.

If schema is found with circular reference, DAB will throw below
exception.

**DAB Exception**
``` c#
DataApiBuilderException(
                        message: $"Circular reference detected in the schema for entity '{entityType}'.",
                        statusCode: System.Net.HttpStatusCode.InternalServerError,
                        subStatusCode: DataApiBuilderException.SubStatusCodes.ErrorInInitialization);
```

**Schema with circular reference**
```gql

type Character {
    id : ID,
    name : String,
    moons: [Moon],    // Character has Moon Reference 
}
type Planet @model(name:""Planet"") {
    id : ID!,
    name : String,
    character: Character
}
type Moon {
    id : ID,
    name : String,
    details : String,
    character: Character // Moon has Character Reference
}
```

## How was this tested?

- [x] Integration Tests
- [x] Unit Tests

Author: sourabh1007

src/Core/Services/MetadataProviders/CosmosSqlMetadataProvider.cs

@@ -187,26 +187,48 @@ private void ParseSchemaGraphQLFieldsForJoins()
         /// 4. Check if we get previous entity with join information, if yes append it to the current entity also
         /// 5. Recursively call this function, to process the schema
         /// </summary>
-        /// <param name="fields"></param>
-        /// <param name="schemaDocument"></param>
-        /// <param name="currentPath"></param>
-        /// <param name="previousEntity">indicates the parent entity for which we are processing the schema.</param>
-        private void ProcessSchema(IReadOnlyList<FieldDefinitionNode> fields,
+        /// <param name="fields">All the fields of an entity</param>
+        /// <param name="schemaDocument">Schema Documents, useful to get fields information of an entity</param>
+        /// <param name="currentPath">Generated path of an entity</param>
+        /// <param name="tableCounter">Counter used to generate table alias</param>
+        /// <param name="parentEntity">indicates the parent entity for which we are processing the schema.
+        /// It is useful to get the JOIN statement information and create further new statements</param>
+        /// <param name="visitedEntities"> Keeps a track of the path in an entity, to detect circular reference</param>
+        /// <remarks>It detects the circular reference in the schema while processing the schema and throws <seealso cref="DataApiBuilderException"/> </remarks>
+        private void ProcessSchema(
+            IReadOnlyList<FieldDefinitionNode> fields,
             Dictionary<string, ObjectTypeDefinitionNode> schemaDocument,
             string currentPath,
             IncrementingInteger tableCounter,
-            EntityDbPolicyCosmosModel? previousEntity = null)
+            EntityDbPolicyCosmosModel? parentEntity = null,
+            HashSet<string>? visitedEntities = null)
         {
             // Traverse the fields and add them to the path
             foreach (FieldDefinitionNode field in fields)
             {
-                string entityType = field.Type.NamedType().Name.Value;
-                // If the entity is not in the runtime config, skip it
-                if (!_runtimeConfig.Entities.ContainsKey(entityType))
+                // Create a tracker to keep track of visited entities to detect circular references
+                HashSet<string> trackerForFields = new();
+                if (visitedEntities is not null)
+                {
+                    trackerForFields = visitedEntities;
+                }
+
+                // If the entity is build-in type, do not go further to check circular reference
+                if (GraphQLUtils.IsBuiltInType(field.Type))
                 {
                     continue;
                 }
 
+                string entityType = field.Type.NamedType().Name.Value;
+                // If the entity is already visited, then it is a circular reference
+                if (!trackerForFields.Add(entityType))
+                {
+                    throw new DataApiBuilderException(
+                        message: $"Circular reference detected in the provided GraphQL schema for entity '{entityType}'.",
+                        statusCode: System.Net.HttpStatusCode.InternalServerError,
+                        subStatusCode: DataApiBuilderException.SubStatusCodes.ErrorInInitialization);
+                }
+
                 string? alias = null;
                 bool isArrayType = field.Type is ListTypeNode;
                 if (isArrayType)
@@ -235,15 +257,15 @@ private void ProcessSchema(IReadOnlyList<FieldDefinitionNode> fields,
                         });
                 }
 
-                if (previousEntity is not null)
+                if (parentEntity is not null)
                 {
                     if (string.IsNullOrEmpty(currentEntity.JoinStatement))
                     {
-                        currentEntity.JoinStatement = previousEntity.JoinStatement;
+                        currentEntity.JoinStatement = parentEntity.JoinStatement;
                     }
                     else
                     {
-                        currentEntity.JoinStatement = previousEntity.JoinStatement + " JOIN " + currentEntity.JoinStatement;
+                        currentEntity.JoinStatement = parentEntity.JoinStatement + " JOIN " + currentEntity.JoinStatement;
                     }
                 }
 
@@ -253,7 +275,8 @@ private void ProcessSchema(IReadOnlyList<FieldDefinitionNode> fields,
                     schemaDocument: schemaDocument,
                     currentPath: isArrayType ? $"{alias}" : $"{currentPath}.{field.Name.Value}",
                     tableCounter: tableCounter,
-                    previousEntity: isArrayType ? currentEntity : null);
+                    parentEntity: isArrayType ? currentEntity : null,
+                    visitedEntities: trackerForFields);
             }
         }
 

src/Service.Tests/Configuration/ConfigurationTests.cs

@@ -425,6 +425,48 @@ public class ConfigurationTests
             }
         }";
 
+        internal const string GRAPHQL_SCHEMA_WITH_CYCLE_ARRAY = @"
+type Character {
+    id : ID,
+    name : String,
+    moons: [Moon],
+}
+
+type Planet @model(name:""Planet"") {
+    id : ID!,
+    name : String,
+    character: Character
+}
+
+type Moon {
+    id : ID,
+    name : String,
+    details : String,
+    character: Character
+}
+";
+
+        internal const string GRAPHQL_SCHEMA_WITH_CYCLE_OBJECT = @"
+type Character {
+    id : ID,
+    name : String,
+    moons: Moon,
+}
+
+type Planet @model(name:""Planet"") {
+    id : ID!,
+    name : String,
+    character: Character
+}
+
+type Moon {
+    id : ID,
+    name : String,
+    details : String,
+    character: Character
+}
+";
+
         [TestCleanup]
         public void CleanupAfterEachTest()
         {
@@ -2938,6 +2980,41 @@ public async Task TestEngineSupportViewsWithoutKeyFieldsInConfigForMsSQL()
             }
         }
 
+        /// <summary>
+        /// In CosmosDB NoSQL, we store data in the form of JSON. Practically, JSON can be very complex.
+        /// But DAB doesn't support JSON with circular references e.g if 'Character.Moon' is a valid JSON Path, then
+        /// 'Moon.Character' should not be there, DAB would throw an exception during the load itself.
+        /// </summary>
+        /// <exception cref="ApplicationException"></exception>
+        [TestMethod, TestCategory(TestCategory.COSMOSDBNOSQL)]
+        [DataRow(GRAPHQL_SCHEMA_WITH_CYCLE_OBJECT, DisplayName = "When Circular Reference is there with Object type (i.e. 'Moon' in 'Character' Entity")]
+        [DataRow(GRAPHQL_SCHEMA_WITH_CYCLE_ARRAY, DisplayName = "When Circular Reference is there with Array type (i.e. '[Moon]' in 'Character' Entity")]
+        public void ValidateGraphQLSchemaForCircularReference(string schema)
+        {
+            // Read the base config from the file system
+            TestHelper.SetupDatabaseEnvironment(TestCategory.COSMOSDBNOSQL);
+            FileSystemRuntimeConfigLoader baseLoader = TestHelper.GetRuntimeConfigLoader();
+            if (!baseLoader.TryLoadKnownConfig(out RuntimeConfig baseConfig))
+            {
+                throw new ApplicationException("Failed to load the default CosmosDB_NoSQL config and cannot continue with tests.");
+            }
+
+            // Setup a mock file system, and use that one with the loader/provider for the config
+            MockFileSystem fileSystem = new(new Dictionary<string, MockFileData>()
+            {
+                { @"../schema.gql", new MockFileData(schema) },
+                { DEFAULT_CONFIG_FILE_NAME, new MockFileData(baseConfig.ToJson()) }
+            });
+            FileSystemRuntimeConfigLoader loader = new(fileSystem);
+            RuntimeConfigProvider provider = new(loader);
+
+            DataApiBuilderException exception =
+                Assert.ThrowsException<DataApiBuilderException>(() => new CosmosSqlMetadataProvider(provider, fileSystem));
+            Assert.AreEqual("Circular reference detected in the provided GraphQL schema for entity 'Character'.", exception.Message);
+            Assert.AreEqual(HttpStatusCode.InternalServerError, exception.StatusCode);
+            Assert.AreEqual(DataApiBuilderException.SubStatusCodes.ErrorInInitialization, exception.SubStatusCode);
+        }
+
         /// <summary>
         /// When you query, DAB loads schema and check for defined entities in the config file which get load during DAB initialization, and
         /// it fails during this check if entity is not defined in the config file. In this test case, we are testing the error message is appropriate.