The name "....FilterInput" was already registered by another type.

[bo55vxr]

My Graph QL sits over the top of multiple APIs and some of these APIs have classess with the same name. Consider the following..

namespace MyApp.CustomerServices
{
    public class Customer
    {
        [UseFiltering]
        public IEnumerable<Address> Addresses {get; set;}
    }
    public class Address
    {
        public string Addr1 {get; set;}
        public string Addr2 {get; set;}
        public string Addr3 {get; set;}
    }
}

namespace MyApp.SupplierServices
{
    public class Supplier
    {
        [UseFiltering]
        public IEnumerable<Address> Addresses {get; set;}
    }

    public class Address
    {
        public string AddrLine1 {get; set;}
        public string AddrLine2 {get; set;}
        public string AddrLine3 {get; set;}
    }
}

As you can see, I have two separate name spaces each with an Address class but slightly different.

The start up of the Graph QL system performs with no error, however when I send in a request I then get this error.

The name \u0060AddressFilterInput\u0060 was already registered by another type. (HotChocolate.Data.Filters.FilterInputType\u003CMyApp.SupplierServices.Address\u003E)

This is obviously because there are TWO addresses classes, albeit in different namespaces, but HC does not seem to recognise that.

Other than changing the name of one of the classes, is there any way to tell HC to name the filter differently?

[sigmarsson]

Yeah and unfortunately the annotation [GraphQLName("")] does not impact either the schema generation. I have not understood yet Stitching, perhaps it can be harnessed to resolve this or that would resolve this only if the different Address classes would be located in different API -s ?

[PascalSenn]

Interesting. Can you share some code? this should work

[sigmarsson]

Do you expect it to be working even in version 11.0.9 ? Because it does not. I apply the annotation on both classes, which are having the same name in different name spaces but to no avail.

[PascalSenn]

@sigmarsson So "." is not valid in a GraphQL type name.

[sigmarsson]

But it is being replaced with an underscore in SDL? Hence the dot will not remain in place?

[sigmarsson]

@PascalSenn I have overridden the DefaultNamingConventions GetType(Type type) method and indeed, I witness the name is actually equals to the value, which is specified in [GraphQLName("")] . But this does not seem to affect the ListFilterInputType* because the error keep persisting. Why ?

[PascalSenn]

@bo55vxr You can either override the NamingConvetions (create a subclass of DefaultNamingConvntions and override GetTypeName and register it on the schema) or you can create customer filter types and override the names. e.g.

public class AddressFilterInputType: FilterInpuType<Address> 
{
   protected override void Configure(IFilterInputTypeDesdcriptor descriptor) => descriptor.Name("SomeName");
}

[GraphQLName] should actully also work. (apparently @sigmarsson has issues with it though)

[sigmarsson]

The v 11 documentation is wrong relating to protected override void Configure() because is actually sealed .

[PascalSenn]

@sigmarsson That would be bad as this is the configuration interface :) have a look here Source

There are two Configure method. The generic type only seales the Confiure of the non generic one

[bo55vxr]

Bit of a dumb question, but how to I register the new public class AddressFilterInputType: FilterInpuType<Address> in Progam.cs?

[bo55vxr]

FYI - I am using v12

[sigmarsson]

@bo55vxr what helped me to resolve collision among *FilterInputType* was overriding GetTypeName()

builder.Services.AddGraphQLServer().AddConvention<IFilterConvention, MyFilterConvention>();

    public class MyFilterConvention : FilterConvention
    {
        public override NameString GetTypeName(Type type)
        {
            ...     
            return base.GetTypeName(type);
        }

        protected override void Configure(IFilterConventionDescriptor descriptor)
        {
            descriptor.AddDefaults();
        }
    }

[bo55vxr]

Hi @sigmarsson (Nice Avatar BTW)

So, using the details provided, I have created the following class

public class ContactDetailsConvention : FilterConvention
{
    public override NameString GetTypeName(Type type)
    {
        return base.GetTypeName(type);
    }

    protected override void Configure(IFilterConventionDescriptor descriptor)
    {
        descriptor.AddDefaults();
    }
}

And then registered it

IRequestExecutorBuilder hc = services.AddGraphQLServer()
                                                             .AddAuthorization()
                                                             .AddFiltering()
                                                             .AddSorting()
                                                             .AddErrorFilter<ErrorFilter>()
                                                             /* These prevent Filter "collisions" where class names are the same */
                                                             .AddConvention<IFilterConvention, ContactDetailsConvention>();

When I run the code and make a schema request (from Postman), if then throws the following exception

There are two conventions registered for HotChocolate.Data.Filters.IFilterConvention in scope default. Only one convention is allowed. Use convention extensions if additional configuration is needed. Colliding conventions are HotChocolate.Data.Filters.FilterConvention and VAA.EAPI.GraphQL.Domain.CreateCustomer.Models.ContactDetailsConvention
(VAA.EAPI.GraphQL.Domain.Loyalty.Queries.CustomerType)

Using v12.15.0 of HC

[bo55vxr]

Well, using all the information here, and a bit of creative coding, I managed to now resolve everything I need.

1. With a custom IFilterConvention, I am required to remove the .AddFiltering() registration
2. In the custom filter, you have to manipulate the response to provide a unique name so the way I implemented this was to use a custom class attribute and decorate each of the duplicate classes. In the filter, check the Type that has been passed to see if this attribute is present and if so use the name provided, else use the default name.

Custom Filter and Attribute

using HotChocolate;
using HotChocolate.Data;
using HotChocolate.Data.Filters;
using System;
using System.Linq;

namespace MyProject.Middleware
{
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
    public class MyCustomFilterConventionAttribute: Attribute
    {
        public string FilterName { get; }

        public MyCustomFilterConventionAttribute(string filterName)
        {
            FilterName = filterName;
        }
    }
    public class MyCustomFilterConvention: FilterConvention
    {
        public override NameString GetTypeName(Type type)
        {
            NameString result = base.GetTypeName(type);

            var attr = type.GetCustomAttributes(false).FirstOrDefault(attr => attr is MyCustomFilterConventionAttribute);
            if (attr is not null)
            {
                result = ((MyCustomFilterConventionAttribute)attr).FilterName;
            }
            return result;
        }

        protected override void Configure(IFilterConventionDescriptor descriptor)
        {
            descriptor.AddDefaults();
        }
    }
}

Registering

IRequestExecutorBuilder hc = services.AddGraphQLServer()
                                     .AddAuthorization()
                                     .AddFiltering<MyCustomFilterConvention>()
                                     .AddSorting()
                                     .AddErrorFilter<ErrorFilter>();

Service A Models

namespace MyProject.Models.ServiceA
{
    [MyCustomFilterConventionAttribute(filterName: "ServiceAContactDetailsFilter")]
    [GraphQLName("ServiceAContactDetails")]
    public class ContactDetails
    {
        ....
    }
}

Servce B Models

namespace MyProject.Models.ServiceB
{
    [MyCustomFilterConventionAttribute(filterName: "ServiceBContactDetailsFilter")]
    [GraphQLName("ServiceBContactDetails")]
    public class ContactDetails
    {
        ....
    }
}

[bo55vxr]

@PascalSenn / @sigmarsson - Would welcome a critique review ;)

[rtomita-plana]

I had a very similar issue, but in my case, just overriding the filters wasn't enough. I had to extend the HotChocolate.Types.Descriptors.DefaultNamingConventions class to actually fix the issue my good:

public class MyCustomNamingConventions : DefaultNamingConventions
{
    public override string GetTypeName(Type type)
    {
        // my custom code here.
    }

    public override string GetTypeName(Type type, TypeKind kind)
    {
        // my custom code here.
    }
}

The code in the class is almost identical to the original base class, except that it's intented to substitute the original GetGraphQLName() extension method call with a private method that again, replicates the original almost identically, just to replace a return typeName ?? type.Name line with some custom private method resolver that will consider part of the namespace of the class in the name: return typeName ?? MyCustomNameResolver(type);

And to make it work, just add .AddConvention<INamingConventions, MyCustomNamingConventions>() to the GraphQL extensions list and it works for all filters, sortings, ect.