Ectograph is a set of utility functions for using Ecto in combination with graphql-elixir/graphql.

{
  :ecto, "~> 2.0.2",
  :graphql, "~> 0.3.1"
}

Features:

• Map a Ecto.Type to a GraphQL.Type
• Map a Ecto.Schema to a GraphQL.Type.ObjectType
• Provide extra GraphQL types, such as DateTime
• Utilities to help build a GraphQL schema

How to use

Schemas

defmodule Schemas.Quote do
  use Ecto.Schema

  schema "quotes" do
    field :quote, :string
    field :author, :string

    timestamps
  end

end

Ectograph.Schema.cast(Schemas.Quote)
# %GraphQL.Type.ObjectType{ name: "quotes", fields: %{ quote: %{ type: ... }, ... }}

Types

Ectograph.Type.cast(:string)
# %GraphQL.Type.String{}

Ectograph.Type.cast({ :array, :integer })
# %GraphQL.Type.List{ ofType: :integer }

Utilities

schema = %GraphQL.Schema{
  query: %GraphQL.Type.ObjectType{
    name: "Queries",
    description: "GraphQL Queries",
    fields: %{
      quotes: Ectograph.Definitions.build(Quote, :all, ~w()a),
      quote: Ectograph.Definitions.build(Quote, :get, ~w(id)a),
    },
  },
}

# BUILD FUNCTION:
# Quote   = Resolver module
# :get    = method on resolver that will be called
# ~w(id)a = List of fields that will be used as arguments

# NOTE:
# Either the resolver itself is an Ecto schema,
# or you define a function called 'ecto_schema' that
# returns the Ecto schema.

See the integration tests for a working example, and the docs for more info.

# Adding extra arguments to a query
Ectograph.Definitions.extend_arguments(
  put_field_aka_definition_here,
  %{ extra_argument: %{ type: %GraphQL.Type.String{} }}
)

# Adding extra fields to a query
Ectograph.Definitions.extend_type_fields(
  put_field_aka_definition_here,
  %{ extra_field: %{ type: %GraphQL.Type.Int{} }}
)

# Adding associations
Ectograph.Definitions.add_association(
  put_field_aka_definition_here,
  Resolver,
  :association_name,
  :multiple # or :single (default = :single)
)

Maps

How to use maps as arguments in mutations:

defmodule Example do
  use Ecto.Schema

  schema "examples" do
    field :attributes, :map
  end

  def create(_, args, _) do
    is_map? args[:attributes] # true
  end
end

schema = %GraphQL.Schema{
  mutation: %GraphQL.Type.ObjectType{
    fields: %{
      create: Ectograph.Definitions.build(Example, :create, ~w(attributes)a),
    },
  },
}

Query:

mutation _ {
  create (attributes: { example: "test" }) { attributes }
}

Query with variables:

mutation _ ($attributes: Map) {
  create (attributes: $attributes) { attributes }
}

Note: Apparently it doesn't matter which type you put there. Could be $attributes: Object too.

Installation

If available in Hex, the package can be installed as:

1. Add ectograph to your list of dependencies in mix.exs:

   def deps do [{:ectograph, "~> 0.2.0"}] end

2. Ensure ectograph is started before your application:

   def application do [applications: [:ectograph]] end

To do

Things that are missing or could be improved

• Embedded schemas
• Associations

Ecto types that still have to be implemented:

• binary
• decimal
• date
• time
• composite types