Splitting up Query and Mutation in multiple .graphql files

[bartenra]

Our query.graphql and mutation.graphql files were getting a bit unwieldy, so I wrote some code that allows us to split them up.

As an example, we can now define a comments.graphql with all types and mutations:

type Comment {
  ...
}
type Mutation {
  addComment(...): ...
}

and for another feature, let's say for user management inside user.graphql:

type User {
  ...
}

type Mutation {
  register(): User 
}

Both Mutation definitions will be merged in the final schema.

Here is the code

SchemaMerger

import re
from collections import defaultdict
from typing import List, Union, Literal


class GatheringType:
  def __init__(self, graphql_type: str) -> None:
      self.graphql_type = graphql_type


class SchemaMerger:
  def __init__(self):
      self.schema_str = ""
      self.state: Union[Literal["start"], GatheringType] = "start"
      self.types = defaultdict(str)

  def process_line(self, line: str):
      if self.state == "start":
          if match := re.match(r"^type (Query|Mutation) {", line):
              self.state = GatheringType(match[1])
          else:
              self.schema_str += line

      elif isinstance(self.state, GatheringType):
          if re.match(r"^}", line):
              self.state = "start"
          else:
              self.types[self.state.graphql_type] += line

  def get_schema(self):
      if isinstance(self.state, GatheringType):
          raise RuntimeError(
              f"Cannot get schema, unterminated GraphQL type: {self.state.graphql_type}"
          )
      elif self.state != "start":
          raise RuntimeError("Wrong end state")

      return self.schema_str + "\n".join(
          map(lambda kv: f"type {kv[0]} {{\n{kv[1]}}}", self.types.items())
      )


def readlines_from_files(file_names: List[str]):
  for file_name in file_names:
      with open(file_name) as f:
          for line in f.readlines():
              yield line


def read_schemas_merged(files: List[str]) -> str:
  schema_merger = SchemaMerger()
  for line in readlines_from_files(files):
      schema_merger.process_line(line)
  return schema_merger.get_schema()

Here's how we call it:

from ariadne import gql
from ariadne.load_schema import walk_graphql_files

schema_file_path = Path(__file__).parent.parent.parent / "graphql/public"
schema_files = list(walk_graphql_files(str(schema_file_path)))
schema_str = read_schemas_merged(schema_files)

sdl_schema = gql(schema_str)

Hope this is helpful to someone.

[rafalp]

You can also split large type files into small ones using extend type in your schema:

type Mutation {
    mutationA(): Result
}

extend type Mutation {
    mutationB(): Result2
    mutationC(): Result3
}

[rafalp]

We are also working on new API for library that should be more manageable for large schemas, which early version is available here: https://github.com/mirumee/ariadne/tree/new-object-api/ariadne_future

[betaboon]

the name of that branch sounds interesting, but it's nowhere to be found.
did anything come of it ?

ignore me, i just found it in this PR

[rafalp]

Hey @betaboon, we've released that as separate library: ariadne-graphql-modules

Release discussion can be found here