absinthe

defmodule Absinthe.Schema do
  import Absinthe.Schema.Notation

  @moduledoc """
  Define a GraphQL schema.

  See also `Absinthe.Schema.Notation` for a reference of the macros imported by
  this module available to build types for your schema.

  ## Basic Usage

  To define a schema, `use Absinthe.Schema` within
  a module. This marks your module as adhering to the
  `Absinthe.Schema` behaviour, and sets up some macros
  and utility functions for your use:

  ```
  defmodule App.Schema do
    use Absinthe.Schema

    # ... define it here!

  end
  ```

  Now, define a `query` (and optionally, `mutation`
  and `subscription`).

  We'll define a `query` that has one field, `item`, to support
  querying for an item record by its ID:

  ```
  # Just for the example. You're probably using Ecto or
  # something much more interesting than a module attribute-based
  # database!
  @fake_db %{
    "foo" => %{id: "foo", name: "Foo", value: 4},
    "bar" => %{id: "bar", name: "Bar", value: 5}
  }

  query do
    @desc "Get an item by ID"
    field :item, :item do

      @desc "The ID of the item"
      arg :id, type: :id

      resolve fn %{id: id}, _ ->
        {:ok, Map.get(@fake_db, id)}
      end
    end
  end
  ```

  For more information on object types (especially how the `resolve`
  function works above), see `Absinthe.Type.Object`.

  You may also notice we've declared that the resolved value of the field
  to be of `type: :item`. We now need to define exactly what an `:item` is,
  and what fields it contains.

  ```
  @desc "A valuable Item"
  object :item do
    field :id, :id

    @desc "The item's name"
    field :name, :string,

    field :value, :integer, description: "Recently appraised value"
  end
  ```

  We can also load types from other modules using the `import_types`
  macro:

  ```
  defmodule App.Schema do
    use Absinthe.Schema

    import_types App.Schema.Scalars
    import_types App.Schema.Objects

    # ... schema definition

  end
  ```

  Our `:item` type above could then move into `App.Schema.Objects`:

  ```
  defmodule App.Schema.Objects do
    use Absinthe.Schema.Notation

    object :item do
      # ... type definition
    end

    # ... other objects!

  end
  ```

  ## Default Resolver

  By default, if a `resolve` function is not provided for a field, Absinthe
  will attempt to extract the value of the field using `Map.get/2` with the
  (atom) name of the field.

  You can change this behavior by setting your own custom default resolve
  function in your schema. For example, given we have a field, `name`:

  ```
  field :name, :string
  ```

  And we're trying to extract values from a horrible backend API that gives us
  maps with uppercase (!) string keys:

  ```
  %{"NAME" => "A name"}
  ```

  Here's how we could set our custom resolver to expect those keys:

  ```
  default_resolve fn
    _, %{source: source, definition: %{name: name}} when is_map(source) ->
      {:ok, Map.get(source, String.upcase(name))}
    _, _ ->
      {:ok, nil}
  end
  ```

  Note this will now act as the default resolver for all fields in our schema
  without their own `resolve` function.
  """

  @typedoc """
  A module defining a schema.
  """
  @type t :: module

  alias Absinthe.Type
  alias Absinthe.Language
  alias __MODULE__

  @doc """
  Return the default middleware set for a field if none exists
  """
  def ensure_middleware([], %{identifier: identifier}, _) do
    [{Absinthe.Middleware.MapGet, identifier}]
  end
  def ensure_middleware(middleware, _field, _object) do
    middleware
  end

  defmacro __using__(opts \\ []) do
    quote do
      use Absinthe.Schema.Notation, unquote(opts)
      import unquote(__MODULE__), only: :macros

      import_types Absinthe.Type.BuiltIns

      @after_compile unquote(__MODULE__)
      @behaviour unquote(__MODULE__)

      @doc false
      def __absinthe_middleware__(middleware, field, %{name: "__" <> _} = object) do
        # if we have the double underscore prefix we're dealing with introspection
        # types, which should use the built in default middleware
        middleware
        |> Absinthe.Schema.ensure_middleware(field, object)
        |> __do_absinthe_middleware__(field, object)
      end
      def __absinthe_middleware__(middleware, field, %{identifier: :mutation} = object) do
        # mutation objects should run publication triggers
        middleware
        |> Absinthe.Subscription.add_middleware
        |> __do_absinthe_middleware__(field, object)
      end
      def __absinthe_middleware__(middleware, field, object) do
        __do_absinthe_middleware__(middleware, field, object)
      end

      defp __do_absinthe_middleware__(middleware, field, object) do
        middleware
        |> __MODULE__.middleware(field, object) # run field against user supplied function
        |> Absinthe.Schema.ensure_middleware(field, object) # if they forgot to add middleware set the default
      end

      @doc false
      def middleware(middleware, _field, _object) do
        middleware
      end

      @doc false
      def __absinthe_lookup__(key) do
        key
        |> __absinthe_type__
        |> case do
          %Absinthe.Type.Object{} = object ->
            fields = Map.new(object.fields, fn
              {identifier, field} ->
                {identifier, %{field | middleware: __absinthe_middleware__(field.middleware, field, object)}}
            end)

            %{object | fields: fields}
          type ->
            type
        end
      end

      @doc false
      def plugins do
        Absinthe.Plugin.defaults()
      end

      defoverridable middleware: 3, plugins: 0
    end
  end

  @callback plugins() :: [Absinthe.Plugin.t]

  @doc false
  def __after_compile__(env, _bytecode) do
    [
      env.module.__absinthe_errors__,
      Schema.Rule.check(env.module)
    ]
    |> List.flatten
    |> case do
      [] ->
        nil
      details ->
        raise Absinthe.Schema.Error, details
    end
  end

  defmacro default_resolve(_) do
    raise """
    Don't use this anymore, instead use middleware, see the middleware
    module doc.

    If you had this before:
    ```
    default_resolve fn parent, _args, info ->
      # stuff here
    end
    ```

    Instead do:
    ```
    def middleware([], _field, _object) do
      middleware_spec = Absinthe.Resolution.resolver_spec(fn parent, _args, info ->
        # stuff here
      end)

      [middleware_spec]
    end
    def middleware(middleware, _, _) do
      middleware
    end
    ```
    """
    []
  end

  @default_query_name "RootQueryType"
  @doc """
  Defines a root Query object
  """
  defmacro query(raw_attrs \\ [name: @default_query_name], [do: block]) do
    record_query(__CALLER__, raw_attrs, block)
  end

  defp record_query(env, raw_attrs, block) do
    attrs =
      raw_attrs
      |> Keyword.put_new(:name, @default_query_name)
      |> Keyword.put(:identifier, :query)
    Absinthe.Schema.Notation.scope(env, :object, :query, attrs, block)
  end

  @default_mutation_name "RootMutationType"
  @doc """
  Defines a root Mutation object

  ```
  mutation do
    field :create_user, :user do
      arg :name, non_nulL(:string)
      arg :email, non_nulL(:string)

      resolve &MyApp.Web.BlogResolvers.create_user/2
    end
  end
  ```
  """
  defmacro mutation(raw_attrs \\ [name: @default_mutation_name], [do: block]) do
    record_mutation(__CALLER__, raw_attrs, block)
  end

  defp record_mutation(env, raw_attrs, block) do
    attrs =
      raw_attrs
      |> Keyword.put_new(:name, @default_mutation_name)
      |> Keyword.put(:identifier, :mutation)
    Absinthe.Schema.Notation.scope(env, :object, :mutation, attrs, block)
  end

  @default_subscription_name "RootSubscriptionType"
  @doc """
  Defines a root Subscription object

  Subscriptions in GraphQL let a client submit a document to the server that
  outlines what data they want to receive in the event of particular updates.

  For a full walk through of how to setup your project with subscriptions and
  Phoenix see the Absinthe.Phoenix project moduledoc.

  When you push a mutation, you can have selections on that mutation result
  to get back data you need, IE

  ```
  mutation {
    createUser(accountId: 1, name: "bob") {
      id
      account { name}
    }
  }
  ```

  However, what if you want to know whe OTHER people create a new user, so that
  your UI can update as well. This is the point of subscriptions.

  ```
  subscription {
    newUsers {
      id
      account { name}
    }
  }
  ```

  The job of the subscription macros then is to give you the tools to connect
  subscription documents with the values that will drive them. In the last example
  we would get all users for all accounts, but you could imagine wanting just
  `newUsers(accountId: 2)`.

  In your schema you articulate the interests of a subscription via the `topic`
  macro:

  ```
  subscription do
    field :new_users, :user do
      arg :account_id, non_null(:id)

      topic fn args ->
        args.account_id
      end
    end
  end
  ```
  The topic can be any term. You can broadcast a value manually to this subscription
  by doing

  ```
  Absinthe.Subscription.publish(pubsub, user, [new_users: user.account_id])
  ```

  It's pretty common to want to associate particular mutations as the triggers
  for one or more subscriptions, so Absinthe provides some macros to help with
  that too.

  ```
  subscription do
    field :new_users, :user do
      arg :account_id, non_null(:id)

      topic fn args ->
        args.account_id
      end

      trigger :create_user, topic: fn user ->
        user.account_id
      end
    end
  end
  ```

  The idea with a trigger is that it takes either a single mutation `:create_user`
  or a list of mutations `[:create_user, :blah_user, ...]` and a topic function.
  This function returns a value that is used to lookup documents on the basis of
  the topic they returned from the `topic` macro.

  Note that a subscription field can have `trigger` as many trigger blocks as you
  need, in the event that different groups of mutations return different results
  that require different topic functions.
  """
  defmacro subscription(raw_attrs \\ [name: @default_subscription_name], [do: block]) do
    record_subscription(__CALLER__, raw_attrs, block)
  end

  defp record_subscription(env, raw_attrs, block) do
    attrs =
      raw_attrs
      |> Keyword.put_new(:name, @default_subscription_name)
      |> Keyword.put(:identifier, :subscription)
    Absinthe.Schema.Notation.scope(env, :object, :subscription, attrs, block)
  end

  # Lookup a directive that in used by/available to a schema
  @doc """
  Lookup a directive.
  """
  @spec lookup_directive(t, atom | binary) :: Type.Directive.t | nil
  def lookup_directive(schema, name) do
    schema.__absinthe_directive__(name)
  end

  @doc """
  Lookup a type by name, identifier, or by unwrapping.
  """
  @spec lookup_type(atom, Type.wrapping_t | Type.t | Type.identifier_t, Keyword.t) :: Type.t | nil
  def lookup_type(schema, type, options \\ [unwrap: true]) do
    cond do
      is_atom(type) ->
        cached_lookup_type(schema, type)
      is_binary(type) ->
        cached_lookup_type(schema, type)
      Type.wrapped?(type) ->
        if Keyword.get(options, :unwrap) do
          lookup_type(schema, type |> Type.unwrap)
        else
          type
        end
      true ->
        type
    end
  end

  @doc false
  def cached_lookup_type(schema, type) do
    # TODO: elaborate on why we're using the pdict.
    case :erlang.get({schema, type}) do
      :undefined ->
        result = schema.__absinthe_lookup__(type)
        :erlang.put({schema, type}, result)
        result
      result ->
        result
    end
  end

  @doc """
  List all types on a schema
  """
  @spec types(t) :: [Type.t]
  def types(schema) do
    schema.__absinthe_types__
    |> Map.keys
    |> Enum.map(&lookup_type(schema, &1))
  end

  @doc """
  Get all concrete types for union, interface, or object
  """
  @spec concrete_types(t, Type.t) :: [Type.t]
  def concrete_types(schema, %Type.Union{} = type) do
    Enum.map(type.types, &lookup_type(schema, &1))
  end
  def concrete_types(schema, %Type.Interface{} = type) do
    implementors(schema, type)
  end
  def concrete_types(_, %Type.Object{} = type) do
    [type]
  end
  def concrete_types(_, type) do
    [type]
  end

  @doc """
  List all directives on a schema
  """
  @spec directives(t) :: [Type.Directive.t]
  def directives(schema) do
    schema.__absinthe_directives__
    |> Map.keys
    |> Enum.map(&lookup_directive(schema, &1))
  end

  @doc """
  List all implementors of an interface on a schema
  """
  @spec implementors(t, Type.identifier_t | Type.Interface.t) :: [Type.Object.t]
  def implementors(schema, ident) when is_atom(ident) do
    schema.__absinthe_interface_implementors__
    |> Map.get(ident, [])
    |> Enum.map(&lookup_type(schema, &1))
  end
  def implementors(schema, %Type.Interface{} = iface) do
    implementors(schema, iface.__reference__.identifier)
  end

  @doc false
  @spec type_from_ast(t, Language.type_reference_t) :: Absinthe.Type.t | nil
  def type_from_ast(schema, %Language.NonNullType{type: inner_type}) do
    case type_from_ast(schema, inner_type) do
      nil -> nil
      type -> %Type.NonNull{of_type: type}
    end
  end
  def type_from_ast(schema, %Language.ListType{type: inner_type}) do
    case type_from_ast(schema, inner_type) do
      nil -> nil
      type -> %Type.List{of_type: type}
    end
  end
  def type_from_ast(schema, ast_type) do
    Schema.types(schema)
    |> Enum.find(fn
      %{name: name} ->
        name == ast_type.name
    end)
  end

end