Fix import_types/2 for A.{B, C}

lib/absinthe/phase/schema/type_imports.ex

@@ -17,7 +17,9 @@ defmodule Absinthe.Phase.Schema.TypeImports do
     {Absinthe.Type.BuiltIns.Introspection, []}
   ]
   def handle_imports(%Schema.SchemaDefinition{} = schema) do
-    types = do_imports(@default_imports ++ schema.imports, schema.type_definitions)
+    {types, schema} =
+      do_imports(@default_imports ++ schema.imports, schema.type_definitions, schema)
+
     # special casing the import of the built in directives
     [builtins] = Absinthe.Type.BuiltIns.Directives.__absinthe_blueprint__().schema_definitions
     directives = schema.directive_definitions ++ builtins.directive_definitions
@@ -26,25 +28,43 @@ defmodule Absinthe.Phase.Schema.TypeImports do
 
   def handle_imports(node), do: node
 
-  defp do_imports([], types) do
-    types
+  defp do_imports([], types, schema) do
+    {types, schema}
   end
 
-  defp do_imports([{module, opts} | rest], acc) do
-    [other_def] = module.__absinthe_blueprint__.schema_definitions
+  defp do_imports([{module, opts} | rest], acc, schema) do
+    case Code.ensure_compiled(module) do
+      {:module, module} ->
+        [other_def] = module.__absinthe_blueprint__.schema_definitions
+
+        rejections =
+          MapSet.new([:query, :mutation, :subscription] ++ Keyword.get(opts, :except, []))
 
-    rejections = MapSet.new([:query, :mutation, :subscription] ++ Keyword.get(opts, :except, []))
+        types = Enum.reject(other_def.type_definitions, &(&1.identifier in rejections))
 
-    types = Enum.reject(other_def.type_definitions, &(&1.identifier in rejections))
+        types =
+          case Keyword.fetch(opts, :only) do
+            {:ok, selections} ->
+              Enum.filter(types, &(&1.identifier in selections))
 
-    case Keyword.fetch(opts, :only) do
-      {:ok, selections} ->
-        Enum.filter(types, &(&1.identifier in selections))
+            _ ->
+              types
+          end
 
-      _ ->
-        types
+        do_imports(other_def.imports ++ rest, types ++ acc, schema)
+
+      {:error, reason} ->
+        do_imports(rest, acc, schema |> put_error(error(module, reason)))
     end
+  end
 
-    do_imports(other_def.imports ++ rest, types ++ acc)
+  # Generate an error when loading module fails
+  @spec error(module :: module(), error :: :embedded | :badfile | :nofile | :on_load_failure) ::
+          Absinthe.Phase.Error.t()
+  defp error(module, reason) do
+    %Absinthe.Phase.Error{
+      message: "Could not load module `#{module}`. It returned reason: `#{reason}`.",
+      phase: __MODULE__
+    }
   end
 end

lib/absinthe/schema/notation.ex

@@ -1680,11 +1680,7 @@ defmodule Absinthe.Schema.Notation do
     for {_, _, leaf} <- modules_ast_list do
       type_module = Module.concat([root_module_with_alias | leaf])
 
-      if Code.ensure_loaded?(type_module) do
-        do_import_types(type_module, env, opts)
-      else
-        raise ArgumentError, "module #{type_module} is not available"
-      end
+      do_import_types(type_module, env, opts)
     end
   end
 

test/absinthe/schema/notation/import_test.exs

@@ -251,6 +251,17 @@ defmodule Absinthe.Schema.Notation.ImportTest do
     end
   end
 
+  describe "unknown imported modules" do
+    test "returns error" do
+      assert_schema_error("unknown_import_schema", [
+        %Absinthe.Phase.Error{
+          message: "Could not load module `Elixir.Test.Unknown`. It returned reason: `nofile`.",
+          phase: Absinthe.Phase.Schema.TypeImports
+        }
+      ])
+    end
+  end
+
   defp validate(schema) do
     pipeline =
       schema

test/support/fixtures/dynamic/unknown_import_schema.exs

@@ -0,0 +1,8 @@
+defmodule Absinthe.TestSupport.Schema.UnknownImportSchema do
+  use Absinthe.Schema
+
+  import_types Test.Unknown
+
+  query do
+  end
+end