Ectograph is a set of utility functions for using Ecto in combination with graphql-elixir/graphql
Elixir
Switch branches/tags
Nothing to show
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Failed to load latest commit information.
config
lib
test
.gitignore
CHANGELOG.md
LICENSE
README.md
mix.exs
mix.lock

README.md

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