In this function we want to return an `object-type-definition', but we need to resolve it from an abstract type. We cannot use the interface/union itself, so we need to find the actual implementors.
General algorithm here:
If abstract-type = interface
If abstract-type = union
So what we need is to be able to check the actual name up against the
proper types as defined in the schema. Is it reasonable to expect from
the users to use our implementation of defclass? Let's say we have a
make-object or something like that. Then we can
make sure that the user supplies the proper name. This would make us
not rely on casing when checking types in the abstract
resolver. Possibly other places as well.
With such an implementation we can actually make sure that the types returned from database etc can be checked up against the ones defined in the schema.
This is now implemented in master, so at least we have a starting off point for this.