Generating name and description fields for queries and mutations as per the naming guidelines

src/Service.GraphQLBuilder/GraphQLNaming.cs

@@ -140,11 +140,6 @@ public static string FormatNameForField(string name)
             return string.Join("", nameSegments.Select((n, i) => $"{(i == 0 ? char.ToLowerInvariant(n[0]) : char.ToUpperInvariant(n[0]))}{n[1..]}"));
         }
 
-        public static string FormatNameForField(NameNode name)
-        {
-            return FormatNameForField(name.Value);
-        }
-
         /// <summary>
         /// Helper to pluralize the value of a NameNode HotChocolate schema object
         /// </summary>
@@ -178,7 +173,7 @@ public static NameNode Pluralize(string name, Entity configEntity)
                 return new NameNode(namingRules.Plural);
             }
 
-            return new NameNode(name.Pluralize());
+            return new NameNode(name.Pluralize(inputIsKnownToBeSingular: false));
         }
 
         /// <summary>

src/Service.GraphQLBuilder/Mutations/CreateMutationBuilder.cs

@@ -255,10 +255,11 @@ public static FieldDefinitionNode Build(
                 fieldDefinitionNodeDirectives.Add(authorizeDirective!);
             }
 
+            string singularName = GetDefinedSingularName(name.Value, entity);
             return new(
                 location: null,
-                new NameNode($"create{GetDefinedSingularName(name.Value, entity)}"),
-                new StringValueNode($"Creates a new {name}"),
+                new NameNode($"create{singularName}"),
+                new StringValueNode($"Creates a new {singularName}"),
                 new List<InputValueDefinitionNode> {
                 new InputValueDefinitionNode(
                     location : null,

src/Service.GraphQLBuilder/Mutations/DeleteMutationBuilder.cs

@@ -56,10 +56,11 @@ public static FieldDefinitionNode Build(
                 fieldDefinitionNodeDirectives.Add(authorizeDirective!);
             }
 
+            string singularName = GetDefinedSingularName(name.Value, configEntity);
             return new(
                 null,
-                new NameNode($"delete{GetDefinedSingularName(name.Value, configEntity)}"),
-                new StringValueNode($"Delete a {name}"),
+                new NameNode($"delete{singularName}"),
+                new StringValueNode($"Delete a {singularName}"),
                 inputValues,
                 new NamedTypeNode(name),
                 fieldDefinitionNodeDirectives

src/Service.GraphQLBuilder/Mutations/UpdateMutationBuilder.cs

@@ -242,10 +242,11 @@ public static FieldDefinitionNode Build(
                 fieldDefinitionNodeDirectives.Add(authorizeDirective!);
             }
 
+            string singularName = GetDefinedSingularName(name.Value, entities[dbEntityName]);
             return new(
                 location: null,
-                new NameNode($"update{GetDefinedSingularName(name.Value, entities[dbEntityName])}"),
-                new StringValueNode($"Updates a {name}"),
+                new NameNode($"update{singularName}"),
+                new StringValueNode($"Updates a {singularName}"),
                 inputValues,
                 new NamedTypeNode(name),
                 fieldDefinitionNodeDirectives

src/Service.GraphQLBuilder/Queries/QueryBuilder.cs

@@ -57,7 +57,7 @@ public static DocumentNode Build(
                     if (rolesAllowedForRead.Count() > 0)
                     {
                         queryFields.Add(GenerateGetAllQuery(objectTypeDefinitionNode, name, returnType, inputTypes, entity, rolesAllowedForRead));
-                        queryFields.Add(GenerateByPKQuery(objectTypeDefinitionNode, name, databaseType, rolesAllowedForRead));
+                        queryFields.Add(GenerateByPKQuery(objectTypeDefinitionNode, name, databaseType, entity, rolesAllowedForRead));
                     }
                 }
             }
@@ -70,7 +70,12 @@ public static DocumentNode Build(
             return new(definitionNodes);
         }
 
-        public static FieldDefinitionNode GenerateByPKQuery(ObjectTypeDefinitionNode objectTypeDefinitionNode, NameNode name, DatabaseType databaseType, IEnumerable<string>? rolesAllowedForRead = null)
+        public static FieldDefinitionNode GenerateByPKQuery(
+            ObjectTypeDefinitionNode objectTypeDefinitionNode,
+            NameNode name,
+            DatabaseType databaseType,
+            Entity entity,
+            IEnumerable<string>? rolesAllowedForRead = null)
         {
             IEnumerable<FieldDefinitionNode> primaryKeyFields =
             FindPrimaryKeyFields(objectTypeDefinitionNode, databaseType);
@@ -95,10 +100,11 @@ public static FieldDefinitionNode GenerateByPKQuery(ObjectTypeDefinitionNode obj
                     new List<DirectiveNode>()));
             }
 
+            string singularName = GetDefinedSingularName(name.Value, entity);
             return new(
                 location: null,
-                new NameNode($"{FormatNameForField(name)}_by_pk"),
-                new StringValueNode($"Get a {name} from the database by its ID/primary key"),
+                new NameNode($"{FormatNameForField(singularName)}_by_pk"),
+                new StringValueNode($"Get a {singularName} from the database by its ID/primary key"),
                 inputValues,
                 new NamedTypeNode(name),
                 fieldDefinitionNodeDirectives
@@ -141,8 +147,8 @@ public static FieldDefinitionNode GenerateGetAllQuery(
             //    books(first: Int, after: String, filter: BooksFilterInput, orderBy: BooksOrderByInput): BooksConnection!
             return new(
                 location: null,
-                new NameNode(FormatNameForField(Pluralize(name, entity))),
-                new StringValueNode($"Get a list of all the {name} items from the database"),
+                new NameNode(FormatNameForField(Pluralize(name, entity).Value)),
+                new StringValueNode($"Get a list of all the {GetDefinedSingularName(name.Value, entity)} items from the database"),
                 QueryArgumentsForField(filterInputName, orderByInputName),
                 new NonNullTypeNode(new NamedTypeNode(returnType.Name)),
                 fieldDefinitionNodeDirectives

src/Service.Tests/GraphQLBuilder/Helpers/GraphQLTestHelpers.cs

@@ -11,6 +11,34 @@ namespace Azure.DataApiBuilder.Service.Tests.GraphQLBuilder.Helpers
 {
     public static class GraphQLTestHelpers
     {
+        public const string BOOK_GQL =
+                    @"
+                    type Book @model(name:""Book"") {
+                        book_id: Int! @primaryKey
+                    }
+                    ";
+
+        public const string BOOKS_GQL =
+                    @"
+                    type Books @model(name:""Books"") {
+                        book_id: Int! @primaryKey
+                    }
+                    ";
+
+        public const string PERSON_GQL =
+                    @"
+                    type Person @model(name:""Person"") {
+                        person_id: Int! @primaryKey
+                    }
+                    ";
+
+        public const string PEOPLE_GQL =
+                    @"
+                    type People @model(name:""People"") {
+                        people_id: Int! @primaryKey
+                    }
+                    ";
+
         /// <summary>
         /// Mock the entityPermissionsMap which resolves which roles need to be included
         /// in an authorize directive used on a GraphQL object type definition.
@@ -46,6 +74,36 @@ public static Entity GenerateEmptyEntity()
             return new Entity("foo", Rest: null, GraphQL: null, Array.Empty<PermissionSetting>(), Relationships: new(), Mappings: new());
         }
 
+        /// <summary>
+        /// Creates an entity with a SingularPlural GraphQL type.
+        /// </summary>
+        /// <param name="singularNameForEntity"> Singular name defined by user in the config.</param>
+        /// <param name="pluralNameForEntity"> Plural name defined by user in the config.</param>
+        public static Entity GenerateEntityWithSingularPlural(string singularNameForEntity, string pluralNameForEntity)
+        {
+            return new Entity(Source: "foo",
+                              Rest: null,
+                              GraphQL: new GraphQLEntitySettings(new SingularPlural(singularNameForEntity, pluralNameForEntity)),
+                              Permissions: Array.Empty<PermissionSetting>(),
+                              Relationships: new(),
+                              Mappings: new());
+        }
+
+        /// <summary>
+        /// Creates an entity with a string GraphQL type.
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public static Entity GenerateEntityWithStringType(string type)
+        {
+            return new Entity(Source: "foo",
+                              Rest: null,
+                              GraphQL: new GraphQLEntitySettings(type),
+                              Permissions: Array.Empty<PermissionSetting>(),
+                              Relationships: new(),
+                              Mappings: new());
+        }
+
         /// <summary>
         /// Ensures that for each fieldDefinition present:
         /// - One @authorize directive found

src/Service.Tests/GraphQLBuilder/MutationBuilderTests.cs

@@ -923,5 +923,84 @@ public static ObjectTypeDefinitionNode GetMutationNode(DocumentNode mutationRoot
             FieldDefinitionNode field = query.Fields.First(f => f.Name.Value == $"updateFoo");
             return (mutationRoot, field);
         }
+
+        /// <summary>
+        /// We assume that the user will provide a singular name for the entity. Users have the option of providing singular and
+        /// plural names for an entity in the config to have more control over the graphql schema generation.
+        /// When singular and plural names are specified by the user, these names will be used for generating the
+        /// queries and mutations in the schema.
+        /// When singular and plural names are not provided, the queries and mutations will be generated with the entity's name.
+        /// This test validates that this naming convention is followed for the mutations when the schema is generated.
+        /// </summary>
+        /// <param name="gql">Type definition for the entity</param>
+        /// <param name="entityName">Name of the entity</param>
+        /// <param name="singularName">Singular name provided by the user</param>
+        /// <param name="pluralName">Plural name provided by the user</param>
+        /// <param name="expectedName"> Expected name of the entity in the mutation. Used to construct the exact expected mutation names.</param>
+        [DataTestMethod]
+        [DataRow(GraphQLTestHelpers.PEOPLE_GQL, "People", null, null, "People",
+            DisplayName = "Mutation name and description validation for singular entity name with singular plural not defined")]
+        [DataRow(GraphQLTestHelpers.PEOPLE_GQL, "People", "Person", "People", "Person",
+            DisplayName = "Mutaiton name and description validation for plural entity name with singular plural defined")]
+        [DataRow(GraphQLTestHelpers.PEOPLE_GQL, "People", "Person", "", "Person",
+            DisplayName = "Mutation name and description validation for plural entity name with singular defined")]
+        [DataRow(GraphQLTestHelpers.PERSON_GQL, "Person", null, null, "Person",
+            DisplayName = "Mutation name and description validation for singular entity name with singular plural not defined")]
+        [DataRow(GraphQLTestHelpers.PERSON_GQL, "Person", "Person", "People", "Person",
+            DisplayName = "Mutation name and description validation for singular entity name with singular plural defined")]
+        public void ValidateMutationsAreCreatedWithRightName(
+            string gql,
+            string entityName,
+            string singularName,
+            string pluralName,
+            string expectedName
+            )
+        {
+            DocumentNode root = Utf8GraphQLParser.Parse(gql);
+            Dictionary<string, EntityMetadata> entityPermissionsMap = GraphQLTestHelpers.CreateStubEntityPermissionsMap(
+                    new string[] { entityName },
+                    new Operation[] { Operation.Create, Operation.Update, Operation.Delete },
+                    new string[] { "anonymous", "authenticated" });
+
+            Entity entity = (singularName is not null)
+                                ? GraphQLTestHelpers.GenerateEntityWithSingularPlural(singularName, pluralName)
+                                : GraphQLTestHelpers.GenerateEmptyEntity();
+
+            DocumentNode mutationRoot = MutationBuilder.Build(
+                root,
+                DatabaseType.cosmos,
+                new Dictionary<string, Entity> { { entityName, entity } },
+                entityPermissionsMap: entityPermissionsMap
+                );
+
+            ObjectTypeDefinitionNode mutation = GetMutationNode(mutationRoot);
+            Assert.IsNotNull(mutation);
+
+            // The permissions are setup for create, update and delete operations.
+            // So create, update and delete mutations should get generated.
+            // A Check to validate that the count of mutations generated is 3.
+            Assert.AreEqual(3, mutation.Fields.Count);
+
+            // Name and Description validations for Create mutation
+            string expectedCreateMutationName = $"create{expectedName}";
+            string expectedCreateMutationDescription = $"Creates a new {expectedName}";
+            Assert.AreEqual(1, mutation.Fields.Count(f => f.Name.Value == expectedCreateMutationName));
+            FieldDefinitionNode createMutation = mutation.Fields.First(f => f.Name.Value == expectedCreateMutationName);
+            Assert.AreEqual(expectedCreateMutationDescription, createMutation.Description.Value);
+
+            // Name and Description validations for Update mutation
+            string expectedUpdateMutationName = $"update{expectedName}";
+            string expectedUpdateMutationDescription = $"Updates a {expectedName}";
+            Assert.AreEqual(1, mutation.Fields.Count(f => f.Name.Value == expectedUpdateMutationName));
+            FieldDefinitionNode updateMutation = mutation.Fields.First(f => f.Name.Value == expectedUpdateMutationName);
+            Assert.AreEqual(expectedUpdateMutationDescription, updateMutation.Description.Value);
+
+            // Name and Description validations for Delete mutation
+            string expectedDeleteMutationName = $"delete{expectedName}";
+            string expectedDeleteMutationDescription = $"Delete a {expectedName}";
+            Assert.AreEqual(1, mutation.Fields.Count(f => f.Name.Value == expectedDeleteMutationName));
+            FieldDefinitionNode deleteMutation = mutation.Fields.First(f => f.Name.Value == expectedDeleteMutationName);
+            Assert.AreEqual(expectedDeleteMutationDescription, deleteMutation.Description.Value);
+        }
     }
 }