Schema utils

Author: Josh Price

lib/graphql/schema/generator.ex

@@ -0,0 +1,157 @@
+defmodule GraphQL.Schema.Generator do
+
+  # TODO generate comments with the source types
+
+  def generate(base_filename, source_schema) do
+    {:ok, ast} = GraphQL.Lang.Parser.parse(source_schema)
+    module_name = base_filename |> Path.basename("_schema") |> Macro.camelize
+    {:ok, generate_module(module_name, ast)}
+  end
+
+  def generate_module(name, ast) do
+    """
+    defmodule #{name}.Schema do
+    #{walk_ast(ast)}
+    end
+    """
+  end
+
+  def walk_ast(doc = %{kind: :Document}) do
+    """
+      alias GraphQL.Type
+
+    #{doc.definitions |> Enum.map(&walk_ast/1) |> Enum.join("\n")}
+
+      def schema do
+        %GraphQL.Schema{
+          query: Query.type,
+          # mutation: Mutation.type
+        }
+      end
+    """
+  end
+
+  def walk_ast(type_def = %{kind: :ObjectTypeDefinition}) do
+    """
+      defmodule #{type_def.name.value} do
+        def type do
+          %Type.ObjectType{
+            name: "#{type_def.name.value}",
+            description: "#{type_def.name.value} description",
+            fields: %{
+              #{type_def.fields |> Enum.map(&walk_ast/1) |> Enum.join(",\n          ")}
+            }#{interfaces(type_def)}
+          }
+        end
+      end
+    """
+  end
+
+  def walk_ast(field = %{kind: :FieldDefinition, arguments: args}) when is_list(args) and length(args) > 0 do
+    """
+    #{field.name.value}: %{
+                type: #{walk_ast(field.type)},
+                args: %{
+                  #{args |> Enum.map(&walk_ast/1) |> Enum.join(",\n")}
+                }
+              }
+    """ |> String.strip
+  end
+
+  def walk_ast(input = %{kind: :InputValueDefinition}) do
+    "#{input.name.value}: %{type: #{walk_ast(input.type)}}"
+  end
+
+  def walk_ast(field = %{kind: :FieldDefinition}) do
+    "#{field.name.value}: %{type: #{walk_ast(field.type)}}"
+  end
+
+  def walk_ast(type = %{kind: :NonNullType}) do
+    "%Type.NonNull{ofType: #{walk_ast(type.type)}}"
+  end
+
+  def walk_ast(type = %{kind: :ListType}) do
+    "%Type.List{ofType: #{walk_ast(type.type)}}"
+  end
+
+  def walk_ast(type = %{kind: :NamedType}) do
+    if type.name.value in ~w(String Int ID) do
+      "%Type.#{type.name.value}{}"
+    else
+      type.name.value
+    end
+  end
+
+  def walk_ast(type_def = %{kind: :EnumTypeDefinition}) do
+    """
+      defmodule #{type_def.name.value} do
+        def type do
+          Type.Enum.new %{
+            name: "#{type_def.name.value}",
+            description: "#{type_def.name.value} description",
+            values: %{
+              #{type_def.values |> Enum.map(fn (v) -> "#{v}: %{value: 0}" end) |> Enum.join(",\n          ")}
+            }
+          }
+        end
+      end
+    """
+  end
+
+  def walk_ast(type_def = %{kind: :InterfaceTypeDefinition}) do
+    """
+      defmodule #{type_def.name.value} do
+        def type do
+          Type.Interface.new %{
+            name: "#{type_def.name.value}",
+            description: "#{type_def.name.value} description",
+            fields: %{
+              #{type_def.fields |> Enum.map(&walk_ast/1) |> Enum.join(",\n          ")}
+            }
+          }
+        end
+      end
+    """
+  end
+
+  def walk_ast(type_def = %{kind: :UnionTypeDefinition}) do
+    """
+      defmodule #{type_def.name.value} do
+        def type do
+          GraphQL.Type.Union.new %{
+            name: "#{type_def.name.value}",
+            description: "#{type_def.name.value} description",
+            types: [#{type_def.types |> Enum.map(&walk_ast/1) |> Enum.join(", ")}]
+          }
+        end
+      end
+    """
+  end
+
+  def walk_ast(type_def = %{kind: :ScalarTypeDefinition}) do
+    """
+      defmodule #{type_def.name.value} do
+        def type do
+          GraphQL.Type.Union.new %{
+            name: "#{type_def.name.value}",
+            description: "#{type_def.name.value} description",
+            types: [#{type_def.types |> Enum.map(&walk_ast/1) |> Enum.join(", ")}]
+          }
+        end
+      end
+    """
+  end
+
+  def walk_ast(n) do
+    "#{n.kind} not handled!!!"
+  end
+
+  def interfaces(type_def) do
+    if i = Map.get(type_def, :interfaces) do
+      ",
+        interfaces: [#{Enum.map_join(i, ", ", &(&1.name.value))}]"
+    else
+      ""
+    end
+  end
+end

lib/mix/tasks/compile.graphql.ex

@@ -0,0 +1,78 @@
+defmodule Mix.Tasks.Compile.Graphql do
+  use Mix.Task
+
+  @recursive true
+  @manifest ".compile.graphql"
+
+  @moduledoc """
+  Compiles `.graphql` files which have changed since the last generation.
+
+  Currently only handles schema files, but will support queries in future.
+
+  To use this you need to add the `:graphql` compiler to the front ofyour compiler chain.
+  This just needs to be anywhere before the Elixir compiler because we are
+  generating Elixir code.
+
+  In your `mix.exs` project in a Phoenix project for example:
+
+      compilers: [:phoenix, :graphql] ++ Mix.compilers
+
+  You also need to tell the GraphQL compiler which files to pick up.
+
+  In `config/config.exs`
+
+      config :graphql, source_path: "web/graphql/**/*_schema.graphql"
+
+
+  ## Command line options
+
+    * `--force` - forces compilation regardless of modification times
+
+  """
+
+  @spec run(OptionParser.argv) :: :ok | :noop
+  def run(args) do
+    {opts, _, _} = OptionParser.parse(args, switches: [force: :boolean])
+
+    graphql_schema_glob = Application.get_env(:graphql, :source_path)
+
+    changed =
+      graphql_schema_glob
+      |> Path.wildcard
+      |> compile_all(opts)
+
+    if Enum.any?(changed, &(&1 == :ok)) do
+      :ok
+    else
+      :noop
+    end
+  end
+
+  @doc """
+  Returns GraphQL manifests.
+  """
+  def manifests, do: [manifest]
+  defp manifest, do: Path.join(Mix.Project.manifest_path, @manifest)
+
+  def compile_all(schema_paths, opts) do
+    Enum.map schema_paths, &(compile(&1, opts))
+  end
+
+  def compile(schema_path, opts) do
+    base_filename = extract_file_prefix(schema_path)
+    target = base_filename <> ".ex"
+    if opts[:force] || Mix.Utils.stale?([schema_path], [target]) do
+      Mix.shell.info "Compiling `#{schema_path}` to `#{target}`"
+      with target,
+           {:ok, source_schema}    <- File.read(schema_path),
+           {:ok, generated_schema} <- GraphQL.Schema.Generator.generate(base_filename, source_schema),
+        do: File.write!(target, generated_schema)
+    else
+      Mix.shell.info "Skipping `#{schema_path}`"
+    end
+  end
+
+  def extract_file_prefix(path) do
+    Path.join(Path.dirname(path), Path.basename(path, ".graphql"))
+  end
+end