Expose Content Fields Indexing via GraphQL for content field filtering

src/OrchardCore.Modules/OrchardCore.ContentFields/GraphQL/Fields/ContentFieldsProvider.cs

@@ -3,8 +3,9 @@
 using System.Collections.Generic;
 using GraphQL.Resolvers;
 using GraphQL.Types;
+using OrchardCore.Apis.GraphQL.Queries.Types;
 using OrchardCore.ContentFields.Fields;
-using OrchardCore.ContentFields.GraphQL.Types;
+using OrchardCore.ContentFields.Indexing.SQL;
 using OrchardCore.ContentManagement;
 using OrchardCore.ContentManagement.GraphQL.Queries.Types;
 using OrchardCore.ContentManagement.Metadata.Models;
@@ -23,6 +24,8 @@ public class ContentFieldsProvider : IContentFieldProvider
                     FieldType = typeof(BooleanGraphType),
                     UnderlyingType = typeof(BooleanField),
                     FieldAccessor = field => ((BooleanField)field).Value,
+                    IndexType = typeof(BooleanFieldIndex),
+                    Index = nameof(BooleanFieldIndex.Boolean)
                 }
             },
             {
@@ -33,6 +36,8 @@ public class ContentFieldsProvider : IContentFieldProvider
                     FieldType = typeof(DateGraphType),
                     UnderlyingType = typeof(DateField),
                     FieldAccessor = field => ((DateField)field).Value,
+                    IndexType = typeof(DateFieldIndex),
+                    Index = nameof(DateFieldIndex.Date)
                 }
             },
             {
@@ -43,6 +48,8 @@ public class ContentFieldsProvider : IContentFieldProvider
                     FieldType = typeof(DateTimeGraphType),
                     UnderlyingType = typeof(DateTimeField),
                     FieldAccessor = field => ((DateTimeField)field).Value,
+                    IndexType = typeof(DateTimeFieldIndex),
+                    Index = nameof(DateTimeFieldIndex.DateTime)
                 }
             },
             {
@@ -53,6 +60,8 @@ public class ContentFieldsProvider : IContentFieldProvider
                     FieldType = typeof(DecimalGraphType),
                     UnderlyingType = typeof(NumericField),
                     FieldAccessor = field => ((NumericField)field).Value,
+                    IndexType = typeof(NumericFieldIndex),
+                    Index = nameof(NumericFieldIndex.Numeric)
                 }
             },
             {
@@ -63,6 +72,8 @@ public class ContentFieldsProvider : IContentFieldProvider
                     FieldType = typeof(StringGraphType),
                     UnderlyingType = typeof(TextField),
                     FieldAccessor = field => ((TextField)field).Text,
+                    IndexType = typeof(TextFieldIndex),
+                    Index = nameof(TextFieldIndex.Text)
                 }
             },
             {
@@ -73,6 +84,8 @@ public class ContentFieldsProvider : IContentFieldProvider
                     FieldType = typeof(TimeSpanGraphType),
                     UnderlyingType = typeof(TimeField),
                     FieldAccessor = field => ((TimeField)field).Value,
+                    IndexType = typeof(TimeFieldIndex),
+                    Index = nameof(TimeFieldIndex.Time)
                 }
             },
             {
@@ -118,12 +131,35 @@ public FieldType GetField(ISchema schema, ContentPartFieldDefinition field, stri
 
         public bool HasField(ISchema schema, ContentPartFieldDefinition field) => _contentFieldTypeMappings.ContainsKey(field.FieldDefinition.Name);
 
+        public FieldTypeIndexDescriptor GetFieldIndex(ContentPartFieldDefinition field)
+        {
+            if (!HasFieldIndex(field))
+            {
+                return null;
+            }
+
+            var fieldDescriptor = _contentFieldTypeMappings[field.FieldDefinition.Name];
+
+            return new FieldTypeIndexDescriptor
+            {
+                Index = fieldDescriptor.Index,
+                IndexType = fieldDescriptor.IndexType
+            };
+        }
+
+        public bool HasFieldIndex(ContentPartFieldDefinition field) =>
+            _contentFieldTypeMappings.TryGetValue(field.FieldDefinition.Name, out var fieldTypeDescriptor) &&
+            fieldTypeDescriptor.IndexType != null &&
+            !string.IsNullOrWhiteSpace(fieldTypeDescriptor.Index);
+
         private sealed class FieldTypeDescriptor
         {
             public string Description { get; set; }
             public Type FieldType { get; set; }
             public Type UnderlyingType { get; set; }
             public Func<ContentElement, object> FieldAccessor { get; set; }
+            public string Index { get; set; }
+            public Type IndexType { get; set; }
         }
     }
 }

src/OrchardCore.Modules/OrchardCore.ContentFields/GraphQL/Fields/ObjectGraphTypeFieldProvider.cs

@@ -27,7 +27,8 @@ public FieldType GetField(ISchema schema, ContentPartFieldDefinition field, stri
                     ResolvedType = queryGraphType,
                     Resolver = new FuncFieldResolver<ContentElement, ContentElement>(context =>
                     {
-                        var typeToResolve = context.FieldDefinition.ResolvedType.GetType().BaseType.GetGenericArguments().First();
+                        var typeToResolve = context.FieldDefinition.ResolvedType.GetType().BaseType
+                            .GetGenericArguments().First();
 
                         // Check if part has been collapsed by trying to get the parent part.
                         ContentElement contentPart = context.Source.Get<ContentPart>(field.PartDefinition.Name);
@@ -44,8 +45,15 @@ public FieldType GetField(ISchema schema, ContentPartFieldDefinition field, stri
             return null;
         }
 
+        public FieldTypeIndexDescriptor GetFieldIndex(ContentPartFieldDefinition field)
+        {
+            return null;
+        }
+
         public bool HasField(ISchema schema, ContentPartFieldDefinition field) => GetObjectGraphType(schema, field) != null;
 
+        public bool HasFieldIndex(ContentPartFieldDefinition field) => false;
+
         private static IObjectGraphType GetObjectGraphType(ISchema schema, ContentPartFieldDefinition field) =>
             schema.AdditionalTypeInstances
                 .FirstOrDefault(x => x is IObjectGraphType && x.GetType().BaseType.GetGenericArguments().First().Name == field.FieldDefinition.Name) as IObjectGraphType;

src/OrchardCore.Modules/OrchardCore.ContentFields/GraphQL/Startup.cs

@@ -3,6 +3,7 @@
 using OrchardCore.ContentFields.Fields;
 using OrchardCore.ContentFields.GraphQL.Fields;
 using OrchardCore.ContentFields.GraphQL.Types;
+using OrchardCore.ContentManagement.GraphQL;
 using OrchardCore.ContentManagement.GraphQL.Queries.Types;
 using OrchardCore.Modules;
 
@@ -22,4 +23,13 @@ public override void ConfigureServices(IServiceCollection services)
             services.AddObjectGraphType<UserPickerField, UserPickerFieldQueryObjectType>();
         }
     }
+
+    [RequireFeatures("OrchardCore.Apis.GraphQL", "OrchardCore.ContentFields.Indexing.SQL")]
+    public class IndexStartup : StartupBase
+    {
+        public override void ConfigureServices(IServiceCollection services)
+        {
+            services.AddContentFieldsInputGraphQL();
+        }
+    }
 }

src/OrchardCore.Modules/OrchardCore.ContentTypes/Services/ContentDefinitionService.cs

@@ -369,6 +369,12 @@ await _contentDefinitionManager.AlterPartDefinitionAsync(partViewModel.Name, par
                     fieldBuilder.WithDisplayMode(fieldViewModel.DisplayMode);
                 });
             });
+
+            _contentDefinitionEventHandlers.Invoke((handler, context) => handler.ContentPartFieldUpdated(context), new ContentPartFieldUpdatedContext
+            {
+                ContentPartName = partViewModel.Name,
+                ContentFieldName = fieldViewModel.Name
+            }, _logger);
         }
 
         public async Task AlterTypePartAsync(EditTypePartViewModel typePartViewModel)
@@ -385,10 +391,17 @@ await _contentDefinitionManager.AlterTypeDefinitionAsync(typeDefinition.Name, ty
                     part.WithDisplayMode(typePartViewModel.DisplayMode);
                 });
             });
+
+            _contentDefinitionEventHandlers.Invoke((handler, context) => handler.ContentTypePartUpdated(context), new ContentTypePartUpdatedContext
+            {
+                ContentTypeName = typeDefinition.Name,
+                ContentPartName = typePartViewModel.Name
+            }, _logger);
         }
 
-        public Task AlterTypePartsOrderAsync(ContentTypeDefinition typeDefinition, string[] partNames)
-            => _contentDefinitionManager.AlterTypeDefinitionAsync(typeDefinition.Name, type =>
+        public async Task AlterTypePartsOrderAsync(ContentTypeDefinition typeDefinition, string[] partNames)
+        {
+            await _contentDefinitionManager.AlterTypeDefinitionAsync(typeDefinition.Name, type =>
             {
                 if (partNames is null)
                 {
@@ -411,8 +424,15 @@ public Task AlterTypePartsOrderAsync(ContentTypeDefinition typeDefinition, strin
                 }
             });
 
-        public Task AlterPartFieldsOrderAsync(ContentPartDefinition partDefinition, string[] fieldNames)
-            => _contentDefinitionManager.AlterPartDefinitionAsync(partDefinition.Name, type =>
+            _contentDefinitionEventHandlers.Invoke((handler, context) => handler.ContentTypeUpdated(context), new ContentTypeUpdatedContext
+            {
+                ContentTypeDefinition = typeDefinition
+            }, _logger);
+        }
+
+        public async Task AlterPartFieldsOrderAsync(ContentPartDefinition partDefinition, string[] fieldNames)
+        {
+            await _contentDefinitionManager.AlterPartDefinitionAsync(partDefinition.Name, type =>
             {
                 if (fieldNames is null)
                 {
@@ -429,6 +449,12 @@ public Task AlterPartFieldsOrderAsync(ContentPartDefinition partDefinition, stri
                 }
             });
 
+            _contentDefinitionEventHandlers.Invoke((handler, context) => handler.ContentPartUpdated(context), new ContentPartUpdatedContext
+            {
+                ContentPartDefinition = partDefinition
+            }, _logger);
+        }
+
         public async Task<string> GenerateContentTypeNameFromDisplayNameAsync(string displayName)
         {
             displayName = displayName.ToSafeName();

src/OrchardCore.Modules/OrchardCore.ContentFields/GraphQL/Types/TimeSpanGraphType.cs → src/OrchardCore/OrchardCore.Apis.GraphQL.Abstractions/Queries/Types/TimeSpanGraphType.cs

@@ -3,7 +3,7 @@
 using GraphQL.Types;
 using GraphQLParser.AST;
 
-namespace OrchardCore.ContentFields.GraphQL.Types
+namespace OrchardCore.Apis.GraphQL.Queries.Types
 {
     public class TimeSpanGraphType : ScalarGraphType
     {

src/OrchardCore/OrchardCore.Apis.GraphQL.Abstractions/Queries/WhereInputObjectGraphType.cs

@@ -1,14 +1,22 @@
 using System;
 using System.Collections.Generic;
 using GraphQL.Types;
+using OrchardCore.Apis.GraphQL.Queries.Types;
 
 namespace OrchardCore.Apis.GraphQL.Queries
 {
-    public class WhereInputObjectGraphType : WhereInputObjectGraphType<object>
+    public interface IFilterInputObjectGraphType : IInputObjectGraphType
+    {
+        void AddScalarFilterFields<TGraphType>(string fieldName, string description);
+
+        void AddScalarFilterFields(Type graphType, string fieldName, string description);
+    }
+
+    public class WhereInputObjectGraphType : WhereInputObjectGraphType<object>, IFilterInputObjectGraphType
     {
     }
 
-    public class WhereInputObjectGraphType<TSourceType> : InputObjectGraphType<TSourceType>
+    public class WhereInputObjectGraphType<TSourceType> : InputObjectGraphType<TSourceType>, IFilterInputObjectGraphType
     {
         // arguments of typed input graph types return typed object, without additional input fields (_in, _contains,..)
         // so we return dictionary as it was before.
@@ -51,22 +59,37 @@ public override object ParseDictionary(IDictionary<string, object> value)
             {"_not_ends_with", "does not end with the string"},
         };
 
-        public void AddScalarFilterFields<TGraphType>(string fieldName, string description)
+        public virtual void AddScalarFilterFields<TGraphType>(string fieldName, string description)
         {
             AddScalarFilterFields(typeof(TGraphType), fieldName, description);
         }
 
-        public void AddScalarFilterFields(Type graphType, string fieldName, string description)
+        public virtual void AddScalarFilterFields(Type graphType, string fieldName, string description)
         {
+            if (!typeof(ScalarGraphType).IsAssignableFrom(graphType) &&
+                !typeof(IInputObjectGraphType).IsAssignableFrom(graphType))
+            {
+                return;
+            }
+
             AddEqualityFilters(graphType, fieldName, description);
-            AddMultiValueFilters(graphType, fieldName, description);
 
             if (graphType == typeof(StringGraphType))
             {
+                AddMultiValueFilters(graphType, fieldName, description);
                 AddStringFilters(graphType, fieldName, description);
             }
-            else if (graphType == typeof(DateTimeGraphType))
+            else if (graphType == typeof(DateTimeGraphType) ||
+                graphType == typeof(DateGraphType) ||
+                graphType == typeof(DateOnlyGraphType) ||
+                graphType == typeof(TimeSpanGraphType) ||
+                graphType == typeof(DecimalGraphType) ||
+                graphType == typeof(IntGraphType) ||
+                graphType == typeof(LongGraphType) ||
+                graphType == typeof(FloatGraphType) ||
+                graphType == typeof(BigIntGraphType))
             {
+                AddMultiValueFilters(graphType, fieldName, description);
                 AddNonStringFilters(graphType, fieldName, description);
             }
         }

src/OrchardCore/OrchardCore.ContentManagement.GraphQL/Options/GraphQLContentOptions.cs

@@ -232,7 +232,7 @@ internal static string GetFieldName(ContentTypePartDefinition definition, string
                 return partName.ToFieldName() + fieldName.ToPascalCase();
             }
 
-            return fieldName;
+            return fieldName.ToCamelCase();
         }
     }
 }

src/OrchardCore/OrchardCore.ContentManagement.GraphQL/OrchardCore.ContentManagement.GraphQL.csproj

@@ -17,6 +17,7 @@
   <ItemGroup>
     <ProjectReference Include="..\..\OrchardCore\OrchardCore.Apis.GraphQL.Abstractions\OrchardCore.Apis.GraphQL.Abstractions.csproj" />
     <ProjectReference Include="..\OrchardCore.ContentManagement.Abstractions\OrchardCore.ContentManagement.Abstractions.csproj" />
+    <ProjectReference Include="..\OrchardCore.ContentTypes.Abstractions\OrchardCore.ContentTypes.Abstractions.csproj" />
     <ProjectReference Include="..\OrchardCore.ContentManagement.Display\OrchardCore.ContentManagement.Display.csproj" />
     <ProjectReference Include="..\OrchardCore.ContentManagement\OrchardCore.ContentManagement.csproj" />
     <ProjectReference Include="..\OrchardCore.Contents.Core\OrchardCore.Contents.Core.csproj" />

src/OrchardCore/OrchardCore.ContentManagement.GraphQL/Queries/ContentItemsFieldType.cs

@@ -136,8 +136,10 @@ private IQuery<ContentItem> FilterWhereArguments(
                 foreach (var alias in aliasProvider.GetAliases())
                 {
                     predicateQuery.CreateAlias(alias.Alias, alias.Index);
-                    indexAliases.Add(alias.Alias, alias.Alias);
-                    indexes.TryAdd(alias.Index, alias);
+                    if (indexAliases.TryAdd(alias.Alias, alias.Alias))
+                    {
+                        indexes.TryAdd(alias.Index, alias);
+                    }
                 }
             }
 

src/OrchardCore/OrchardCore.ContentManagement.GraphQL/Queries/Types/ContentItemWhereInput.cs

@@ -1,3 +1,4 @@
+using System;
 using GraphQL.Types;
 using Microsoft.Extensions.Options;
 using OrchardCore.Apis.GraphQL;
@@ -21,26 +22,26 @@ public ContentItemWhereInput(string contentItemName, IOptions<GraphQLContentOpti
 
             Description = $"the {contentItemName} content item filters";
 
-            AddFilterField<IdGraphType>("contentItemId", "content item id");
-            AddFilterField<IdGraphType>("contentItemVersionId", "the content item version id");
-            AddFilterField<StringGraphType>("displayText", "the display text of the content item");
-            AddFilterField<DateTimeGraphType>("createdUtc", "the date and time of creation");
-            AddFilterField<DateTimeGraphType>("modifiedUtc", "the date and time of modification");
-            AddFilterField<DateTimeGraphType>("publishedUtc", "the date and time of publication");
-            AddFilterField<StringGraphType>("owner", "the owner of the content item");
-            AddFilterField<StringGraphType>("author", "the author of the content item");
+            AddScalarFilterFields<IdGraphType>("contentItemId", "content item id");
+            AddScalarFilterFields<IdGraphType>("contentItemVersionId", "the content item version id");
+            AddScalarFilterFields<StringGraphType>("displayText", "the display text of the content item");
+            AddScalarFilterFields<DateTimeGraphType>("createdUtc", "the date and time of creation");
+            AddScalarFilterFields<DateTimeGraphType>("modifiedUtc", "the date and time of modification");
+            AddScalarFilterFields<DateTimeGraphType>("publishedUtc", "the date and time of publication");
+            AddScalarFilterFields<StringGraphType>("owner", "the owner of the content item");
+            AddScalarFilterFields<StringGraphType>("author", "the author of the content item");
 
             var whereInputType = new ListGraphType(this);
             Field<ListGraphType<ContentItemWhereInput>>("Or").Description("OR logical operation").Type(whereInputType);
             Field<ListGraphType<ContentItemWhereInput>>("And").Description("AND logical operation").Type(whereInputType);
             Field<ListGraphType<ContentItemWhereInput>>("Not").Description("NOT logical operation").Type(whereInputType);
         }
 
-        private void AddFilterField<T>(string name, string description)
+        public override void AddScalarFilterFields(Type graphType, string fieldName, string description)
         {
-            if (!_optionsAccessor.Value.ShouldSkip(typeof(ContentItemType), name))
+            if (!_optionsAccessor.Value.ShouldSkip(typeof(ContentItemType), fieldName))
             {
-                AddScalarFilterFields<T>(name, description);
+                base.AddScalarFilterFields(graphType, fieldName, description);
             }
         }
     }