fix: render default values in SDL output for schema.sdl task

Previously, the `mix absinthe.schema.sdl` task would not include default
values for arguments and input object fields in the generated SDL output,
even though the schema.json task included them in its output.

Changes:
- Modified SDL renderer to handle default values for InputValueDefinition
  (arguments) and FieldDefinition (input object fields)
- Added support for DSL-defined schemas where default_value is an Elixir
  term that needs conversion to Blueprint.Input structures
- Added support for SDL-parsed schemas where default_value_blueprint is
  already a Blueprint structure
- Skip non-serializable values (refs, functions)

Tests:
- Added DefaultValueTestSchema with default value coverage to prevent
  regression while rendering boolean, string, and input object default values
- All existing tests updated to expect default values in output

Author: jarrod

lib/absinthe/schema/notation/sdl_render.ex

@@ -70,7 +70,7 @@ defmodule Absinthe.Schema.Notation.SDL.Render do
       string(@adapter.to_external_name(input_value.name, :argument)),
       ": ",
       render(input_value.type, type_definitions),
-      default(input_value.default_value_blueprint),
+      default(input_value),
       directives(input_value.directives, type_definitions)
     ])
     |> description(input_value.description)
@@ -107,7 +107,7 @@ defmodule Absinthe.Schema.Notation.SDL.Render do
         string(input_object_type.name),
         directives(input_object_type.directives, type_definitions)
       ]),
-      render_list(input_object_type.fields, type_definitions)
+      render_input_fields(input_object_type.fields, type_definitions)
     )
     |> description(input_object_type.description)
   end
@@ -306,12 +306,54 @@ defmodule Absinthe.Schema.Notation.SDL.Render do
     )
   end
 
-  defp default(nil) do
+  defp default(%Blueprint.Schema.FieldDefinition{default_value: nil}) do
     empty()
   end
 
-  defp default(default_value) do
-    concat([" = ", render_value(default_value)])
+  defp default(%Blueprint.Schema.FieldDefinition{default_value: {:ref, _, _}}) do
+    empty()
+  end
+
+  defp default(%Blueprint.Schema.FieldDefinition{default_value: default_value})
+       when is_atom(default_value) or is_binary(default_value) or is_number(default_value) or
+              is_boolean(default_value) or is_list(default_value) or is_map(default_value) do
+    try do
+      blueprint_value = Blueprint.Input.parse(default_value)
+      concat([" = ", render_value(blueprint_value)])
+    rescue
+      _ -> empty()
+    end
+  end
+
+  defp default(%Blueprint.Schema.FieldDefinition{}) do
+    empty()
+  end
+
+  defp default(%Blueprint.Schema.InputValueDefinition{
+         default_value_blueprint: nil,
+         default_value: nil
+       }) do
+    empty()
+  end
+
+  defp default(%Blueprint.Schema.InputValueDefinition{
+         default_value_blueprint: nil,
+         default_value: default_value
+       })
+       when not is_nil(default_value) do
+    blueprint_value = Blueprint.Input.parse(default_value)
+    concat([" = ", render_value(blueprint_value)])
+  end
+
+  defp default(%Blueprint.Schema.InputValueDefinition{
+         default_value_blueprint: default_value_blueprint
+       })
+       when not is_nil(default_value_blueprint) do
+    concat([" = ", render_value(default_value_blueprint)])
+  end
+
+  defp default(_) do
+    empty()
   end
 
   defp description(docs, nil) do
@@ -356,6 +398,47 @@ defmodule Absinthe.Schema.Notation.SDL.Render do
 
   # Render Helpers
 
+  defp render_input_fields(fields, type_definitions) do
+    items = Enum.reject(fields, &(&1.module in @skip_modules))
+
+    splitter =
+      items
+      |> Enum.any?(&(&1.description not in ["", nil]))
+      |> case do
+        true -> [nest(line(), :reset), line()]
+        false -> [line()]
+      end
+
+    items
+    |> Enum.reverse()
+    |> Enum.reduce(:start, fn
+      item, :start -> render_input_field(item, type_definitions)
+      item, acc -> concat([render_input_field(item, type_definitions)] ++ splitter ++ [acc])
+    end)
+  end
+
+  defp render_input_field(%Blueprint.Schema.FieldDefinition{} = field, type_definitions) do
+    concat([
+      string(@adapter.to_external_name(field.name, :field)),
+      ": ",
+      render(field.type, type_definitions),
+      default(field),
+      directives(field.directives, type_definitions)
+    ])
+    |> description(field.description)
+  end
+
+  defp render_input_field(%Blueprint.Schema.InputValueDefinition{} = field, type_definitions) do
+    concat([
+      string(@adapter.to_external_name(field.name, :argument)),
+      ": ",
+      render(field.type, type_definitions),
+      default(field),
+      directives(field.directives, type_definitions)
+    ])
+    |> description(field.description)
+  end
+
   defp render_list(items, type_definitions, separator \\ line())
 
   # Workaround for `values` macro which temporarily defines

test/absinthe/schema/sdl_render_test.exs

@@ -275,7 +275,7 @@ defmodule Absinthe.Schema.SdlRenderTest do
              type RootQueryType {
                echo(
                  \"The number of times\"
-                 times: Int
+                 times: Int = 10
 
                  timeInterval: Int
                ): String

test/absinthe/schema/type_system_directive_test.exs

@@ -225,7 +225,7 @@ defmodule Absinthe.Schema.TypeSystemDirectiveTest do
   }
 
   input SearchFilter @feature(name: \":input_object\") {
-    query: String @feature(name: \":input_field_definition\")
+    query: String = "default" @feature(name: \":input_field_definition\")
   }
 
   union SearchResult @feature(name: \":union\") = Dog | Post

test/mix/tasks/absinthe.schema.sdl_test.exs

@@ -123,6 +123,35 @@ defmodule Mix.Tasks.Absinthe.Schema.SdlTest do
     end
   end
 
+  defmodule DefaultValueTestSchema do
+    use Absinthe.Schema
+
+    query do
+      field :item, :string do
+        arg :show, :boolean, default_value: true
+      end
+
+      field :search, :string do
+        arg :filters, :filters, default_value: %{query: "mystring"}
+      end
+    end
+
+    mutation do
+      field :create_item, :string do
+        arg :input, non_null(:test_input)
+        arg :other, :string, default_value: "other"
+      end
+    end
+
+    input_object :filters do
+      field :query, :string
+    end
+
+    input_object :test_input do
+      field :value, non_null(:string), default_value: "test"
+    end
+  end
+
   @test_mod_schema "Mix.Tasks.Absinthe.Schema.SdlTest.TestSchemaWithMods"
 
   setup_all do
@@ -193,5 +222,16 @@ defmodule Mix.Tasks.Absinthe.Schema.SdlTest do
 
       assert File.exists?(path)
     end
+
+    test "with default values" do
+      argv = ["output.graphql", "--schema", "#{DefaultValueTestSchema}"]
+      opts = Task.parse_options(argv)
+
+      {:ok, schema} = Task.generate_schema(opts)
+      assert schema =~ "value: String! = \"test\""
+      assert schema =~ "other: String = \"other\""
+      assert schema =~ "show: Boolean = true"
+      assert schema =~ "filters: Filters = {query: \"mystring\"}"
+    end
   end
 end