Merge branch 'master' into raise-informative-error-on-batched-resolver-timeout

Author: benwilson512

CHANGELOG.md

@@ -2,12 +2,18 @@
 
 ## Unreleased
 
+- Bug Fix: Adds **optional fix** for non compliant built-in scalar Int type. `use Absinthe.Schema, use_spec_compliant_int_scalar: true` in your schema to use the fixed Int type. It is also advisable to upgrade for custom types if you are leveraging the use of integers outside the GraphQl standard. [#1131](https://github.com/absinthe-graphql/absinthe/pull/1131).
+- Feature: [Support error tuples when scalar parsing fails](https://github.com/absinthe-graphql/absinthe/pull/1187)
 - Feature: [Convert SDL Language.\* structs to SDL notation](https://github.com/absinthe-graphql/absinthe/pull/1160)
 - Feature: [Add support for type extensions](https://github.com/absinthe-graphql/absinthe/pull/1157)
+- Bug Fix: [Add type system directives to introspection results](https://github.com/absinthe-graphql/absinthe/pull/1189)
 - Bug Fix: [Add `__private__` field to EnumValueDefinition](https://github.com/absinthe-graphql/absinthe/pull/1148)
 - Bug Fix: [Fix bug in Schema.**absinthe_types**(:all) for Persistent Term](https://github.com/absinthe-graphql/absinthe/pull/1161)
+- Bug Fix: [Fix default enum value check for SDL schema's](https://github.com/absinthe-graphql/absinthe/pull/1188)
 - Feature: [Add `import_directives` macro](https://github.com/absinthe-graphql/absinthe/pull/1158)
 - BugFix: [Improved error when batches fail timeouts](https://github.com/absinthe-graphql/absinthe/pull/1180)
+- Feature: [Support type extensions on schema declarations](https://github.com/absinthe-graphql/absinthe/pull/1176)
+- Bug Fix: [Root objects are marked as referenced correctly](https://github.com/absinthe-graphql/absinthe/pull/1186)
 
 ## 1.7.0
 

README.md

@@ -7,7 +7,7 @@
 [![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![Last Updated](https://img.shields.io/github/last-commit/absinthe-graphql/absinthe.svg)](https://github.com/absinthe-graphql/absinthe/commits/master)
 
-[GraphQL](https://facebook.github.io/graphql/) implementation for Elixir.
+[GraphQL](https://github.com/graphql-elixir/graphql) implementation for Elixir.
 
 Goals:
 
@@ -61,7 +61,7 @@ We care about support for third-party frameworks, both on the back and
 front end.
 
 So far, we include specialized support for Phoenix and Plug on the backend,
-and [Relay](https://facebook.github.io/relay/) on the frontend.
+and [Relay](https://relay.dev/) on the frontend.
 
 Of course we work out of the box with other frontend frameworks and GraphQL
 clients, too.

guides/custom-scalars.md

@@ -15,7 +15,7 @@ providing `parse` and `serialize` functions.
 
 Here's the definition for `:datetime` from `Absinthe.Type.Custom`:
 
-``` elixir
+```elixir
 @desc """
 The `DateTime` scalar type represents a date and time in the UTC
 timezone. The DateTime appears in a JSON response as an ISO8601 formatted
@@ -68,7 +68,7 @@ mutation CreatePost {
 
 If our schema defines a `:published_at` argument with the `:datetime` type:
 
-``` elixir
+```elixir
 field :post, :post do
   arg :published_at, :datetime
   resolve fn _, args, _ ->
@@ -90,10 +90,9 @@ correct result. That result will be used as the value of the
 `:published_at` argument when it's passed to the `:post` field
 resolver.
 
-> It's important to note that---currently---the correct result from a
-> scalar's `parse` function in the event of the error is a lone atom,
-> `:error`, not an error tuple with a reason. In a future version of
-> Absinthe, custom parse errors may be supported.
+In the event of an error, the parse function can return either a lone
+atom `:error` or error tuple e.g. `{:error, "Reason of error"}`. The
+reason will be included in the output of the executed GraphQL document.
 
 The serializer of `:datetime` is a pretty simple affair; it uses the
 `DateTime.to_iso8601/1` utility function. It would be called to

guides/introduction/overview.md

@@ -1,6 +1,6 @@
 # Overview
 
-Absinthe is the GraphQL toolkit for Elixir, an implementation of the [GraphQL specification](https://facebook.github.io/graphql/) built to suit the language's capabilities and idiomatic style.
+Absinthe is the GraphQL toolkit for Elixir, an implementation of the [GraphQL specification](https://github.com/graphql-elixir/graphql) built to suit the language's capabilities and idiomatic style.
 
 The Absinthe project consists of several complementary packages. You can find the full listing on the [absinthe-graphql](https://github.com/absinthe-graphql) GitHub organization page.
 

guides/introspection.md

@@ -1,7 +1,7 @@
 # Schema Introspection
 
 You can introspect your schema using `__schema`, `__type`, and `__typename`,
-as [described in the specification](https://facebook.github.io/graphql/#sec-Introspection).
+as [described in the specification](https://spec.graphql.org/October2021/#sec-Introspection).
 
 ### Examples
 
@@ -89,7 +89,7 @@ Getting the name of the fields for a named type:
 ```
 
 Note that you may have to nest several depths of `type`/`ofType`, as
-type information includes any wrapping layers of [List](https://facebook.github.io/graphql/#sec-List) and/or [NonNull](https://facebook.github.io/graphql/#sec-Non-null).
+type information includes any wrapping layers of [List](https://spec.graphql.org/October2021/#sec-List) and/or [NonNull](https://spec.graphql.org/October2021/#sec-Non-Null).
 
 ## Using GraphiQL
 

guides/tutorial/our-first-query.md

@@ -43,7 +43,7 @@ end
 > custom type name as a `:name` option to the `object` macro.
 
 If you're curious what the type `:id` is used by the `:id` field, see
-the [GraphQL spec](https://facebook.github.io/graphql/#sec-ID). It's
+the [GraphQL spec](https://spec.graphql.org/October2021/#sec-ID). It's
 an opaque value, and in our case is just the regular Ecto id, but
 serialized as a string.
 

guides/variables.md

@@ -2,7 +2,7 @@
 
 GraphQL supports query documents that declare variables that can be accepted to fill-in values. This is a useful mechanism for reusing GraphQL documents---instead of attempting to interpolate values yourself.
 
-- To support variables, simply define them for your query document [as the specification expects](https://facebook.github.io/graphql/#sec-Language.Query-Document.Variables), and pass in a `variables` option to `Absinthe.run`.
+- To support variables, simply define them for your query document [as the specification expects](https://spec.graphql.org/October2021/#sec-Language.Variables), and pass in a `variables` option to `Absinthe.run`.
 - If you're using [absinthe_plug](https://github.com/absinthe-graphql/absinthe_plug), variables are passed in for you automatically after being parsed
 from the query parameters or `POST` body.
 

lib/absinthe/blueprint/schema.ex

@@ -117,7 +117,8 @@ defmodule Absinthe.Blueprint.Schema do
     Schema.InterfaceTypeDefinition,
     Schema.UnionTypeDefinition,
     Schema.EnumValueDefinition,
-    Schema.TypeExtensionDefinition
+    Schema.TypeExtensionDefinition,
+    Schema.SchemaDeclaration
   ]
 
   defp build_types([%module{} = type | rest], stack, buff) when module in @simple_open do
@@ -196,6 +197,7 @@ defmodule Absinthe.Blueprint.Schema do
     Schema.InterfaceTypeDefinition,
     Schema.ObjectTypeDefinition,
     Schema.ScalarTypeDefinition,
+    Schema.SchemaDeclaration,
     Schema.UnionTypeDefinition
   ]
   defp build_types(
@@ -210,6 +212,14 @@ defmodule Absinthe.Blueprint.Schema do
     build_types(rest, [%{extend | definition: def} | stack], buff)
   end
 
+  defp build_types(
+         [:close | rest],
+         [%Schema.FieldDefinition{} = field, %Schema.SchemaDeclaration{} = declaration | stack],
+         buff
+       ) do
+    build_types(rest, [push(declaration, :field_definitions, field) | stack], buff)
+  end
+
   defp build_types([:close | rest], [%Schema.FieldDefinition{} = field, obj | stack], buff) do
     field =
       field
@@ -271,6 +281,17 @@ defmodule Absinthe.Blueprint.Schema do
     build_types(rest, [schema | stack], buff)
   end
 
+  defp build_types(
+         [:close | rest],
+         [%Schema.SchemaDeclaration{} = schema_declaration, schema | stack],
+         buff
+       ) do
+    # The declaration is pushed into the :type_definitions instead of the :schema_declaration
+    # as it will be split off later in the ApplyDeclaration phase
+    schema = push(schema, :type_definitions, schema_declaration)
+    build_types(rest, [schema | stack], buff)
+  end
+
   defp build_types([:close | rest], [%Schema.SchemaDefinition{} = schema, bp], buff) do
     bp = push(bp, :schema_definitions, schema)
     build_types(rest, [bp], buff)

lib/absinthe/blueprint/transform.ex

@@ -86,11 +86,13 @@ defmodule Absinthe.Blueprint.Transform do
     Blueprint.Schema.InterfaceTypeDefinition => [:interfaces, :fields, :directives],
     Blueprint.Schema.ObjectTypeDefinition => [:interfaces, :fields, :directives],
     Blueprint.Schema.ScalarTypeDefinition => [:directives],
+    Blueprint.Schema.SchemaDeclaration => [:directives, :field_definitions],
     Blueprint.Schema.SchemaDefinition => [
       :directive_definitions,
       :type_definitions,
       :type_extensions,
-      :directives
+      :directives,
+      :schema_declaration
     ],
     Blueprint.Schema.TypeExtensionDefinition => [:definition],
     Blueprint.Schema.UnionTypeDefinition => [:directives, :types]

lib/absinthe/formatter.ex

@@ -20,7 +20,7 @@ defmodule Absinthe.Formatter do
     # Define the desired plugins
     plugins: [Absinthe.Formatter],
     # Remember to update the inputs list to include the new extensions
-    inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}", "{lib, priv}/**/*.{gql,graphql}"]
+    inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}", "{lib,priv}/**/*.{gql,graphql}"]
   ]
   ```
   """

lib/absinthe/introspection.ex

@@ -3,7 +3,7 @@ defmodule Absinthe.Introspection do
   Introspection support.
 
   You can introspect your schema using `__schema`, `__type`, and `__typename`,
-  as [described in the specification](https://facebook.github.io/graphql/#sec-Introspection).
+  as [described in the specification](https://spec.graphql.org/October2021/#sec-Introspection).
 
   ## Examples
 
@@ -94,8 +94,8 @@ defmodule Absinthe.Introspection do
   ```
 
   (Note that you may have to nest several depths of `type`/`ofType`, as
-  type information includes any wrapping layers of [List](https://facebook.github.io/graphql/#sec-List)
-  and/or [NonNull](https://facebook.github.io/graphql/#sec-Non-null).)
+  type information includes any wrapping layers of [List](https://spec.graphql.org/October2021/#sec-List)
+  and/or [NonNull](https://spec.graphql.org/October2021/#sec-Non-Null).)
   """
 
   alias Absinthe.Type

lib/absinthe/phase.ex

@@ -25,17 +25,24 @@ defmodule Absinthe.Phase do
       @behaviour Phase
       import(unquote(__MODULE__))
 
-      @spec flag_invalid(Blueprint.node_t()) :: Blueprint.node_t()
+      @spec flag_invalid(node :: Blueprint.node_t()) :: Blueprint.node_t()
       def flag_invalid(%{flags: _} = node) do
         Absinthe.Blueprint.put_flag(node, :invalid, __MODULE__)
       end
 
-      @spec flag_invalid(Blueprint.node_t(), atom) :: Blueprint.node_t()
+      @spec flag_invalid(node :: Blueprint.node_t(), flag :: atom) :: Blueprint.node_t()
       def flag_invalid(%{flags: _} = node, flag) do
         flagging = %{:invalid => __MODULE__, flag => __MODULE__}
         update_in(node.flags, &Map.merge(&1, flagging))
       end
 
+      @spec flag_invalid(node :: Blueprint.node_t(), flag :: atom, reason :: String.t()) ::
+              Blueprint.node_t()
+      def flag_invalid(%{flags: _} = node, flag, reason) do
+        flagging = %{:invalid => {__MODULE__, reason}, flag => __MODULE__}
+        update_in(node.flags, &Map.merge(&1, flagging))
+      end
+
       def put_flag(%{flags: _} = node, flag) do
         Absinthe.Blueprint.put_flag(node, flag, __MODULE__)
       end

lib/absinthe/phase/document/arguments/parse.ex

@@ -26,6 +26,10 @@ defmodule Absinthe.Phase.Document.Arguments.Parse do
 
       {:error, flag} ->
         %{node | normalized: normalized |> flag_invalid(flag)}
+
+      {:error, flag, reason} ->
+        normalized = normalized |> flag_invalid(flag, reason)
+        %{node | normalized: normalized}
     end
   end
 
@@ -41,6 +45,9 @@ defmodule Absinthe.Phase.Document.Arguments.Parse do
       :error ->
         {:error, :bad_parse}
 
+      {:error, reason} ->
+        {:error, :bad_parse, reason}
+
       {:ok, val} ->
         {:ok, val}
     end
@@ -55,6 +62,9 @@ defmodule Absinthe.Phase.Document.Arguments.Parse do
       :error ->
         {:error, :bad_parse}
 
+      {:error, reason} ->
+        {:error, :bad_parse, reason}
+
       {:ok, val} ->
         {:ok, val}
     end

lib/absinthe/phase/document/validation/arguments_of_correct_type.ex

@@ -58,7 +58,7 @@ defmodule Absinthe.Phase.Document.Validation.ArgumentsOfCorrectType do
       {%{schema_node: nil} = child, _} ->
         collect_child_errors(child, schema)
 
-      {%{flags: %{invalid: _}} = child, idx} ->
+      {%{flags: %{invalid: invalid_flag}} = child, idx} ->
         child_type_name =
           child.schema_node
           |> Type.value_type(schema)
@@ -67,7 +67,12 @@ defmodule Absinthe.Phase.Document.Validation.ArgumentsOfCorrectType do
         child_inspected_value = Blueprint.Input.inspect(child)
 
         [
-          value_error_message(idx, child_type_name, child_inspected_value)
+          value_error_message(
+            idx,
+            child_type_name,
+            child_inspected_value,
+            custom_error(invalid_flag)
+          )
           | collect_child_errors(child, schema)
         ]
 
@@ -90,7 +95,7 @@ defmodule Absinthe.Phase.Document.Validation.ArgumentsOfCorrectType do
 
         [unknown_field_error_message(child.name, field_suggestions)]
 
-      %{flags: %{invalid: _}} = child ->
+      %{flags: %{invalid: invalid_flag}} = child ->
         child_type_name =
           Type.value_type(child.schema_node, schema)
           |> Type.name(schema)
@@ -105,7 +110,12 @@ defmodule Absinthe.Phase.Document.Validation.ArgumentsOfCorrectType do
         child_inspected_value = Blueprint.Input.inspect(child.input_value)
 
         [
-          value_error_message(child.name, child_type_name, child_inspected_value)
+          value_error_message(
+            child.name,
+            child_type_name,
+            child_inspected_value,
+            custom_error(invalid_flag)
+          )
           | child_errors
         ]
 
@@ -114,6 +124,13 @@ defmodule Absinthe.Phase.Document.Validation.ArgumentsOfCorrectType do
     end)
   end
 
+  defp collect_child_errors(
+         %Blueprint.Input.Value{normalized: %{flags: %{invalid: {_, reason}}} = norm},
+         schema
+       ) do
+    [reason | collect_child_errors(norm, schema)]
+  end
+
   defp collect_child_errors(%Blueprint.Input.Value{normalized: norm}, schema) do
     collect_child_errors(norm, schema)
   end
@@ -149,13 +166,17 @@ defmodule Absinthe.Phase.Document.Validation.ArgumentsOfCorrectType do
     error_message(arg_name, inspected_value) <> "\n" <> Enum.join(verbose_errors, "\n")
   end
 
-  def value_error_message(id, expected_type_name, inspected_value) when is_integer(id) do
+  def value_error_message(id, expected_type_name, inspected_value, custom_error \\ nil)
+
+  def value_error_message(id, expected_type_name, inspected_value, custom_error)
+      when is_integer(id) do
     ~s(In element ##{id + 1}: ) <>
-      expected_type_error_message(expected_type_name, inspected_value)
+      expected_type_error_message(expected_type_name, inspected_value, custom_error)
   end
 
-  def value_error_message(id, expected_type_name, inspected_value) do
-    ~s(In field "#{id}": ) <> expected_type_error_message(expected_type_name, inspected_value)
+  def value_error_message(id, expected_type_name, inspected_value, custom_error) do
+    ~s(In field "#{id}": ) <>
+      expected_type_error_message(expected_type_name, inspected_value, custom_error)
   end
 
   def unknown_field_error_message(field_name, suggestions \\ [])
@@ -169,7 +190,14 @@ defmodule Absinthe.Phase.Document.Validation.ArgumentsOfCorrectType do
       Utils.MessageSuggestions.suggest_message(suggestions)
   end
 
-  defp expected_type_error_message(expected_type_name, inspected_value) do
+  defp expected_type_error_message(expected_type_name, inspected_value, nil) do
     ~s(Expected type "#{expected_type_name}", found #{inspected_value}.)
   end
+
+  defp expected_type_error_message(expected_type_name, inspected_value, custom_error) do
+    ~s(Expected type "#{expected_type_name}", found #{inspected_value}.\n#{custom_error})
+  end
+
+  defp custom_error({_, reason}), do: reason
+  defp custom_error(_), do: nil
 end