Registered Connections should apply an Interface to the "from" Type signifying it has said connection

[jasonbahl]

When registering a connection, it would be nice if the Type that the connection is coming from implemented an Interface to signify/document that the Type supports said connection.

Let's take Post Type and Taxonomy connections as an example.

We (as developers with prior WordPress experience) know that Posts have Categories and Tags, but we don't know what other Post Types (ContentNodes) have Category/Tag connections. And we also don't inherently know what other Post Types have connections with other Taxonomies. We can browse the Schema a bit to find out have to really know what we're looking for.

If each Post Type that had connections with Term Nodes implemented an Interface such as NodeWithTermNodeConnection we could search this type in a tool such as GraphiQL and find all Types that have connections with Terms.

Let's look at this in SDL to better grasp the idea:

Interface NodeWithTermNodeConnection {
  terms: TermNodeConnection
}

Interface ContentNodeWithTagConnection implements NodeWithTermNodeConnection {
  terms: TermNodeConnection
  tags: TagConnection
}

Interface ContentNodeWithSomeOtherTaxonomyConnection implements NodeWithTermNodeConnection {
  terms: TermNodeConnection
  someOtherTaxonomy: SomeOtherTaxonomyConnection
}

Then the Post Types that are connected with the Taxonomies could implement Interfaces like so:

type Post implements NodeWithTagConnection
type CustomPostType implements NodeWithSomeOtherTaxonomyConnection
type CustomTypeWithNoTaxonomyConnections

Then we could query like so:

{
  post: nodeByUri(uri:"/path-to-post") {
    ...NodeByUri
  }
  customType: nodeByUri(uri:"/path-to-custom-type") {
    ...NodeByUri
  }
  customTypeWithNoTaxonomyConnections: nodeByUri(uri:"/path-to-type-with-no-taxonomy-connection") {
    ...NodeByUri
  }
}

fragment NodeByUri on UniformResourceIdentifiable {
  __typename
  uri
  ...Tags
  ...CustomTaxonomies
  ...AllTerms
}

fragment Tags on NodeWithTagConnection {
  tags {
    nodes {
       __typename
    }
  }
}

fragment CustomTaxonomies on NodeWithCustomTaxonomyConnection {
  customTaxonomies {
    nodes {
      __typename
    }
  }
}

fragment AllTerms on NodeWithTermsConnection {
  terms {
    nodes {
      __typename
    }
  }
}

This would be a valid query. We could query nodes from the root and specify that we want the connected fields only if the node being returned had the connection we were interested in.

We would get a payload like so:

{
  "post": {
    "__typename": "Post",
    "uri": "/path-to-post",
    "tags": {
      "nodes":[ 
        {
          "__typaname": "Tag"     
        }
      ]
    },
    "allTerms": {
      "nodes":[ 
        {
          "__typaname": "Tag"     
        }
      ]
    }
  },
  "customType": {
    "__typename": "CustomType",
    "uri": "/path-to-custom-type",
    "customTaxonomies": {
      "nodes":[ 
        {
          "__typaname": "CustomTaxonomy"     
        }
      ]
    },
    "allTerms": {
      "nodes":[ 
        {
          "__typaname": "CustomTaxonomy"     
        }
      ]
    }
  },
  "customTypeWithNoTaxonomyConnections": {
    "__typename": "CustomTypeWithNoTaxonomyConnections",
    "uri": "/path-to-type-with-no-taxonomy-connection"
  }
}

[stale]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

[stale]

This issue has been automatically closed because it has not had recent activity. If you believe this issue is still valid, please open a new issue and mark this as a related issue.

[stale]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.