Skip to content

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

License

Notifications You must be signed in to change notification settings

icidasset/ectograph

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

31 Commits
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

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

About

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

Topics

Resources

License

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published

Languages