Namespaced Mutations

[zealot128]

Recently, when implementing Indeed's Job API I stumbled across on how they nested their hundreds of mutations into "namespace" types, like:

mutation CreateSourcedJobPostings($input: CreateSourcedJobPostingsInput) {
  jobsIngest {
    createSourcedJobPostings(input: $input) {
      results {
        jobPosting {
          sourcedPostingId
        }
      }
    }
  }
}

As you can see, "createSourcedJObPostings" is nested under "jobsIngest"; from the graphql file:

 type Mutation {
    jobsIngest: JobsIngestMutations
...
}
type JobsIngestMutations {
    createSourcedJobPostings(input: CreateSourcedJobPostingsInput): CreateSourcedJobPostingsPayload
}

This namespace patterns seems to be also supported by Apollo.

I liked that pattern, because when implementing CRUD operations in mutations, the names get so long and repeating. So I tried it with GraphQL-Ruby:

 class MutationType < Types::BaseObject
      class PeopleMutations < Types::BaseObject
        field :update, mutation: Mutations::People::UpdatePerson
        field :create, mutation: Mutations::People::CreatePerson
      end
      field :people_mutations, PeopleMutations, null: false

Which compiles, create a good looking .graphql file:

 type Mutation {
  peopleMutations: MutationPeopleMutations!
}

  type MutationPeopleMutations {
    create(input: PersonFormInput!): CreatePersonPayload
    update(id: Int!, input: PersonFormInput!): UpdatePersonPayload
  }

but when I ran the query:

mutation createPerson($input: PersonFormInput!) {
  peopleMutations {
    create(input: $input) {
      person { id }}}}

I got this error:

   Failed to implement Mutation.peopleMutations, tried:

  - `Types::MutationType#people_mutations`, which did not exist\n              
  - `NilClass#people_mutations`, which did not exist
  - Looking up hash key `:people_mutations` or `\"people_mutations\"` on ``, but it wasn't a Hash\n\n              
  - To implement this field, define one of the methods above (and check for typos), or supply a `fallback_value`.\n",
    "backtrace": [
      "/x/gems/graphql-2.3.5/lib/graphql/schema/field.rb:710:in `block (2 levels) in resolve'",
      "/x/graphql-2.3.5/lib/graphql/schema/field.rb:817:in `with_extensions'",
      "/x/graphql-2.3.5/lib/graphql/schema/field.rb:654:in `block in resolve'",

Reading the error messages, i dabbled around a little, and lo' and behold, this seems to do the trick:

class MutationType < Types::BaseObject
    class PeopleMutations < Types::BaseObject
        field :update, mutation: Mutations::People::UpdatePerson
        field :create, mutation: Mutations::People::CreatePerson
    end
    field :people_mutations, PeopleMutations, null: false
    def people_mutations
      {
        update: Mutations::People::UpdatePerson,
        create: Mutations::People::CreatePerson
      }
    end

Is this accidentally, or a pattern officially supported by GraphQL-Ruby?
If yes, maybe there could be more documentation on it, or some way to reduce the boilerplate of the people_mutations method here.

[rmosolgo]

Hi! Great question. Basically, in order to continue execution, GraphQL-Ruby needs some non-nil object for each field. GraphQL-Ruby doesn't have any special handling for "namespaces" -- they're just plain fields -- so you need any non-nil value for those fields, too. It could be true, or a Symbol like def people_mutations = :people_mutations -- just something so that GraphQL-Ruby can continue execution.

So, the solution you shared above is fine, but it could be even simpler -- it doesn't have to be a hash with keys matching the child field names.

[zealot128]

Great tip, that method returning something also works.

I created a small code generating method:

  class MutationType < Types::BaseObject
    def self.mutation_namespace(name, &block)
      klass = self.const_set(name.to_s.camelize, Class.new(Types::BaseObject, &block))
      field name, klass, null: false
      define_method(name) { name.to_sym }
    end


    mutation_namespace :people_mutations do
      field :update, mutation: Mutations::People::UpdatePerson
      field :create, mutation: Mutations::People::CreatePerson
    end

Works like a charm :)