Absinthe GraphQL for Elixir

Upgrading to v1.5 introduces several breaking changes related to how values and types are validated. Ensure your schema and subscription implementations account for the following:

1. Compile-time Default Values: Default values in your schema are now evaluated at compile time. Using functions like DateTime.utc_now() in a default_value option will fix the value to the time the module was compiled, rather than the time the query is executed.
2. Scalar Output Validation: Scalar outputs are now strictly type-checked. If a resolver returns a data type that does not match the defined scalar type, an exception will be raised.
3. Variable Type Validation: Variable types must align exactly with the argument type. Absinthe no longer allows variables of different types to be used if they happen to parse successfully.
4. Field Name Validation: Field names are now validated against the GraphQL specification. If you need to revert to the previous behavior (allowing invalid field names), remove Absinthe.Phase.Schema.Validation.NamesMustBeValid from your schema pipeline.

To integrate Dataloader into your Absinthe schema, you must perform three steps: define a data source, register it in the context, and enable the middleware plugin.

1. Data Source: Create a module (often your context) that provides a data/0 function returning a Dataloader.Ecto source. 2. Context Setup: In your schema's context/1 function, initialize Dataloader.new(), add your source using Dataloader.add_source/2, and return the loader in the context map under the :loader key. 3. Plugin Registration: Add Absinthe.Middleware.Dataloader to the list returned by your schema's plugins/0 function.

# Example Schema configuration
# Inside your Schema module

def context(ctx) do
  loader = 
    Dataloader.new()
    |> Dataloader.add_source(Blog, Blog.data())

  Map.put(ctx, :loader, loader)
end

def plugins do
  [Absinthe.Middleware.Dataloader] ++ Absinthe.Plugin.defaults()
end

To prevent N+1 query problems and simplify association loading, you can integrate the dataloader Elixir library with Absinthe. This allows you to use the dataloader(Context) resolver syntax in your schema definitions.

1. Add Dependency

Add dataloader to your mix.exs file:

2. Configure the Context and Plugins

In your Absinthe.Schema module, you must:

1. Add Absinthe.Middleware.Dataloader to the plugins/0 list.
2. Initialize a new Dataloader in the context/1 function and add your data source to it.

3. Define the Data Source

Your context module (e.g., Content) should provide a function that returns a Dataloader.Ecto instance (or similar) configured with your Repo and a query function.

# 1. mix.exs
defp deps do
  [
    {:dataloader, "~> 1.0.7"}
  ]
end

# 2. lib/blog/content.ex
def data(), do: Dataloader.Ecto.new(Repo, query: &query/2)

def query(queryable, params) do
  queryable
end

# 3. lib/blog_web/schema.ex
defmodule BlogWeb.Schema do
  use Absinthe.Schema

  def context(ctx) do
     loader = 
       Dataloader.new()
       |> Dataloader.add_source(Content, Content.data())

    Map.put(ctx, :loader, loader)
  end

  def plugins do
    [Absinthe.Middleware.Dataloader | Absinthe.Plugin.defaults()]
  end
end

To connect Apollo Client to an Absinthe server via HTTP, use createHttpLink from @apollo/client. No special Absinthe configuration is required for basic HTTP usage. If you need to include authentication headers (e.g., an Authorization bearer token from a cookie), use the setContext helper to create an authLink and chain it with your httpLink using .concat().

import { ApolloClient, InMemoryCache, createHttpLink } from "@apollo/client";
import { setContext } from "@apollo/client/link/context";
import Cookies from "js-cookie";

// Create an HTTP link to the Absinthe server.
const httpLink = createHttpLink({
  uri: "http://localhost:4000/graphql"
});

// Use setContext to create a chainable link object that sets
// the token cookie to the Authorization header.
const authLink = setContext((_, { headers }) => {
  // Get the authentication token from the cookie if it exists.
  const token = Cookies.get("token");

  // Add the new Authorization header.
  return {
    headers: {
      ...headers,
      authorization: token ? `Bearer ${token}` : ""
    }
  };
});

// Chain the HTTP link and the authorization link.
const link = authLink.concat(httpLink);

const cache = new InMemoryCache();

const client = new ApolloClient({
  link,
  cache
});