Input types and factories

[oojacoboo]

So, I've been playing with trying to get Factories up and running with input types in a sensible dir structure. It's been quite challenging and I think far more challenging than it should have been. Here are a couple things I've noticed and some ideas for improvement.

1. When defining the @Factory(name="Whatever"), if it's not "WhateverInput", meaning it doesn't end in "Input", then when referenced from the controller using UseInputType(for="$input", inputType="Whatever"), GraphQLite throws the Exception:

$input, in [controller method], type "Whatever" must be an input type

2. I find that the multi-directional annotations and Factory associations to be very confusing. It'd be far better if these were defined mostly from a single direction (ala the controller), and there were little constraints. IMO, there is far too many assumptions and automagic going on here and it makes implementation difficult, but also means that, down the road, customization is going to be challenging, assuming that's needed.

Just throwing something out here, but I think the following would be better:

class Mutation
{
  /**
   * Does something.
   *
   * @GraphQLite\Mutation()
   * Could have a "factory" and "method" arg below as well if that syntax is confusing
   * @GraphQLite\HandleInputType(
   *     param="input", 
   *     factory="App\Namespace\Factory::create"
   *     schemaName="ThingInput"
   * )
   * 
   * @param Thing $input
   */
  public function doSomething(Thing $input): Result
  {
    return new Result();
  }
}

Then, the Factory class doesn't really need to do anything special at all. In fact, it just needs to be able to be called via the FQCN from the container and is validated to return a type that matches what's expected from the mutation's method signature.

Additionally, this eliminates the need for this recommendation:

We recommend that you put the factories in the same directories as the types.

I'm finding that having multiple methods within a factory, for a given set of operations is the most natural way of handling things. The default setting is very confusing as well.

[moufmouf]

Hey Jacob!

Very interesting issue! Thanks for opening this.

There are many items in this issue.

The first one is clearly a bug report. I'll clearly have a look at it and try to reproduce it.

Your second suggestion actually makes a lot of sense.
I designed GraphQLite input types to map the way GraphQL input types are handled. I find it interesting to have the ability to declare several input types mapping a given PHP class (and to be able to reuse those input types across queries/mutations).

But you are completely right. Quite often, an input type is used in only one mutation. If this is the case, then having an annotation like your HandleInputType annotation would make a lot of sense. I completely understand this would be a nice shortcut.

I'm trying to keep focused on delivering GraphQLite 4.0 and I believe both solutions are compatible. So I'll keep this as-is for now, and mark this feature to be implemented in 4.1.

[moufmouf]

Hey @oojacoboo ,

I'm trying to reproduce your issue (in step 1):

When defining the @factory(name="Whatever"), if it's not "WhateverInput", meaning it doesn't end in "Input", then when referenced from the controller using UseInputType(for="$input", inputType="Whatever"), GraphQLite throws the Exception:

I cannot reproduce that issue. I have input types that are not ending with "Input" and it works well.

I'm wondering: in your code, is Whatever both an input and an output type? Because this is explicitly forbidden by the GraphQL spec (and that might be the origin of your problem).
I'll write some tests to see how GraphQLite behaves if an input type and an output type have the same name.

[moufmouf]

Ok, I just reproduced your error. It happens if an input type has the same name as an output type.

(this is explicitly forbidden by the GraphQL spec here : https://graphql.org/learn/schema/#input-types )

I'll try to make an exception message that is a bit more clear.

[oojacoboo]

@moufmouf ah, good find. I guess that makes sense. So, the question begs then... how do I reuse the same type for an input and output? It's not unreasonable to expect that someone wants to return and accept the same type.

[moufmouf]

Indeed, a PHP object can map both an input and an output type. But they must have different "names".

This will not work:

/**
 * @Type(name="MyProductType")
 */
class Product {
    /**
     * @Factory(name="MyProductType")
     */
    public function createProduct(...) : Product
    {
        //...
    }
}

This fails because the MyProductType name cannot be used for both input and output type.

However, this will succeed:

/**
 * @Type(name="MyProductOutputType")
 */
class Product {
    /**
     * @Factory(name="MyProductInputType")
     */
    public function createProduct(...) : Product
    {
        //...
    }
}

Even better, if you don't put any name, it works too:

/**
 * @Type()
 */
class Product {
    /**
     * @Factory()
     */
    public function createProduct(...) : Product
    {
        //...
    }
}

By default, the name of the output type will be the name of the class (Product) and the name of the input type will be the name of the class with "Input" appended (so ProductInput).