Fix oneOf/allOf/anyOf and schema module in Discriminator mapping

lib/open_api_spex/cast.ex

@@ -127,9 +127,17 @@ defmodule OpenApiSpex.Cast do
     {:ok, nil}
   end
 
-  # nullable: false
-  def cast(%__MODULE__{value: nil} = ctx) do
-    error(ctx, {:null_value})
+  # nullable not present in root schema or equal to false
+  # dispatch to xxxOf modules if corresponding key is present
+  # or return error
+  def cast(%__MODULE__{value: nil, schema: schema} = ctx) do
+    cond do
+      match?(%{nullable: false}, schema) -> error(ctx, {:null_value})
+      match?(%{oneOf: list} when is_list(list), schema) -> OneOf.cast(ctx)
+      match?(%{anyOf: list} when is_list(list), schema) -> AnyOf.cast(ctx)
+      match?(%{allOf: list} when is_list(list), schema) -> AllOf.cast(ctx)
+      true -> error(ctx, {:null_value})
+    end
   end
 
   # Enum

lib/open_api_spex/cast/all_of.ex

@@ -1,49 +1,18 @@
 defmodule OpenApiSpex.Cast.AllOf do
   @moduledoc false
   alias OpenApiSpex.Cast
+  alias OpenApiSpex.Cast.Utils
   alias OpenApiSpex.Schema
 
   def cast(ctx), do: cast_all_of(ctx, nil)
 
-  defp cast_all_of(%{schema: %{allOf: [%Schema{type: :array} = schema | remaining]}} = ctx, acc)
-       when is_list(acc) or acc == nil do
-    # Since we parse a multi-type array, acc has to be a list or nil
-    acc = acc || []
-
-    case Cast.cast(%{ctx | schema: schema}) do
-      {:ok, value} when is_list(value) ->
-        # Since the cast for the list didn't result in a cast error,
-        # we do not proceed the values through the remaining schemas
-        {:ok, Enum.concat(acc, value)}
-
-      {:error, errors} ->
-        with {:ok, cleaned_ctx} <- reject_error_values(ctx, errors),
-             {:ok, cleaned_values} <- Cast.cast(cleaned_ctx) do
-          new_ctx = put_in(ctx.schema.allOf, remaining)
-          new_ctx = update_in(new_ctx.value, fn values -> values -- cleaned_ctx.value end)
-          cast_all_of(new_ctx, Enum.concat(acc, cleaned_values))
-        else
-          _ -> Cast.error(ctx, {:all_of, to_string(schema.title || schema.type)})
-        end
-    end
-  end
-
   defp cast_all_of(%{schema: %{allOf: [%Schema{} = schema | remaining]}} = ctx, acc) do
-    relaxed_schema = %{schema | additionalProperties: true, "x-struct": nil}
+    relaxed_schema = %{schema | "x-struct": nil}
     new_ctx = put_in(ctx.schema.allOf, remaining)
 
-    case Cast.cast(%{ctx | schema: relaxed_schema}) do
+    case Cast.cast(%{ctx | errors: [], schema: relaxed_schema}) do
       {:ok, value} when is_map(value) ->
-        # Complex allOf Schema
-
-        # reject all "additionalProperties"
-        acc =
-          value
-          |> Enum.reject(fn {k, _} -> is_binary(k) end)
-          |> Enum.concat(acc || %{})
-          |> Map.new()
-
-        cast_all_of(new_ctx, acc)
+        cast_all_of(new_ctx, Utils.merge_maps(acc || %{}, value))
 
       {:ok, value} ->
         # allOf definitions with primitives are a little bit strange.
@@ -52,41 +21,33 @@ defmodule OpenApiSpex.Cast.AllOf do
         # must be compatible with all Schemas
         cast_all_of(new_ctx, acc || value)
 
-      {:error, _} ->
-        # Since in a allOf Schema, every
-        Cast.error(ctx, {:all_of, to_string(relaxed_schema.title || relaxed_schema.type)})
+      {:error, errors} ->
+        Cast.error(
+          %Cast{ctx | errors: ctx.errors ++ errors},
+          {:all_of, to_string(relaxed_schema.title || relaxed_schema.type)}
+        )
     end
   end
 
-  defp cast_all_of(%{schema: %{allOf: [schema | remaining]}} = ctx, result) do
-    schema = OpenApiSpex.resolve_schema(schema, ctx.schemas)
-    cast_all_of(%{ctx | schema: %{allOf: [schema | remaining]}}, result)
+  defp cast_all_of(%{schema: %{allOf: [nested_schema | remaining]} = schema} = ctx, result) do
+    nested_schema = OpenApiSpex.resolve_schema(nested_schema, ctx.schemas)
+    cast_all_of(%{ctx | schema: %{schema | allOf: [nested_schema | remaining]}}, result)
   end
 
-  defp cast_all_of(%{schema: schema} = ctx, nil) do
-    Cast.error(ctx, {:all_of, to_string(schema.title || schema.type)})
-  end
-
-  defp cast_all_of(%{schema: %{allOf: [], "x-struct": module}}, acc) when not is_nil(module),
-    do: {:ok, struct(module, acc)}
-
-  defp cast_all_of(%{schema: %{allOf: []}}, acc) do
-    # All values have been casted against the allOf schemas - return accumulator
-    {:ok, acc}
-  end
-
-  defp reject_error_values(%{value: values} = ctx, [%{reason: :invalid_type} = error | tail]) do
-    new_values = List.delete(values, error.value)
-    reject_error_values(%{ctx | value: new_values}, tail)
+  defp cast_all_of(%{schema: %{allOf: []}, errors: []} = ctx, acc) do
+    with :ok <- Utils.check_required_fields(ctx, acc) do
+      {:ok, acc}
+    end
   end
 
-  defp reject_error_values(ctx, []) do
-    # All errors should now be resolved for the current schema
-    {:ok, ctx}
+  defp cast_all_of(%{schema: %{allOf: [], errors: [], "x-struct": module}} = ctx, acc)
+       when not is_nil(module) do
+    with :ok <- Utils.check_required_fields(ctx, acc) do
+      {:ok, acc}
+    end
   end
 
-  defp reject_error_values(_ctx, errors) do
-    # Some errors couldn't be resolved, we break and return the remaining errors
-    errors
+  defp cast_all_of(%{schema: schema} = ctx, _acc) do
+    Cast.error(ctx, {:all_of, to_string(schema.title || schema.type)})
   end
 end

lib/open_api_spex/cast/any_of.ex

@@ -1,11 +1,13 @@
 defmodule OpenApiSpex.Cast.AnyOf do
   @moduledoc false
   alias OpenApiSpex.Cast
+  alias OpenApiSpex.Cast.Utils
   alias OpenApiSpex.Schema
 
-  def cast(ctx, failed_schemas \\ [], acc \\ nil), do: cast_any_of(ctx, failed_schemas, acc)
+  def cast(ctx, failed_schemas \\ [], acc \\ :__not_casted),
+    do: cast_any_of(ctx, failed_schemas, acc)
 
-  defp cast_any_of(%_{schema: %{anyOf: []}} = ctx, failed_schemas, nil) do
+  defp cast_any_of(%_{schema: %{anyOf: []}} = ctx, failed_schemas, :__not_casted) do
     Cast.error(ctx, {:any_of, error_message(failed_schemas, ctx.schemas)})
   end
 
@@ -14,40 +16,55 @@ defmodule OpenApiSpex.Cast.AnyOf do
          failed_schemas,
          acc
        ) do
-    relaxed_schema = %{schema | additionalProperties: true, "x-struct": nil}
+    relaxed_schema = %{schema | "x-struct": nil}
     new_ctx = put_in(ctx.schema.anyOf, remaining)
 
-    case Cast.cast(%{ctx | schema: relaxed_schema}) do
+    case Cast.cast(%{ctx | errors: [], schema: relaxed_schema}) do
       {:ok, value} when is_struct(value) ->
         {:ok, value}
 
       {:ok, value} when is_map(value) ->
-        acc =
-          value
-          |> Enum.reject(fn {k, _} -> is_binary(k) end)
-          |> Enum.concat(acc || %{})
-          |> Map.new()
-
+        acc = acc |> value_if_not_casted(%{}) |> Utils.merge_maps(value)
         cast_any_of(new_ctx, failed_schemas, acc)
 
       {:ok, value} ->
-        cast_any_of(new_ctx, failed_schemas, acc || value)
-
-      {:error, _} ->
-        cast_any_of(new_ctx, [schema | failed_schemas], acc)
+        cast_any_of(new_ctx, failed_schemas, value_if_not_casted(acc, value))
+
+      {:error, errors} ->
+        cast_any_of(
+          %Cast{new_ctx | errors: new_ctx.errors ++ errors},
+          [schema | failed_schemas],
+          acc
+        )
     end
   end
 
-  defp cast_any_of(%{schema: %{anyOf: [schema | remaining]}} = ctx, failed_schemas, acc) do
-    schema = OpenApiSpex.resolve_schema(schema, ctx.schemas)
-    cast_any_of(%{ctx | schema: %{anyOf: [schema | remaining]}}, failed_schemas, acc)
+  defp cast_any_of(
+         %{schema: %{anyOf: [nested_schema | remaining]} = schema} = ctx,
+         failed_schemas,
+         acc
+       ) do
+    nested_schema = OpenApiSpex.resolve_schema(nested_schema, ctx.schemas)
+
+    cast_any_of(
+      %{ctx | schema: %{schema | anyOf: [nested_schema | remaining]}},
+      failed_schemas,
+      acc
+    )
   end
 
-  defp cast_any_of(%_{schema: %{anyOf: [], "x-struct": module}}, _failed_schemas, acc)
-       when not is_nil(module),
-       do: {:ok, struct(module, acc)}
+  defp cast_any_of(%_{schema: %{anyOf: [], "x-struct": module}} = ctx, _failed_schemas, acc)
+       when not is_nil(module) do
+    with :ok <- Utils.check_required_fields(ctx, acc) do
+      {:ok, struct(module, acc)}
+    end
+  end
 
-  defp cast_any_of(%_{schema: %{anyOf: []}}, _failed_schemas, acc), do: {:ok, acc}
+  defp cast_any_of(%_{schema: %{anyOf: []}} = ctx, _failed_schemas, acc) do
+    with :ok <- Utils.check_required_fields(ctx, acc) do
+      {:ok, acc}
+    end
+  end
 
   ## Private functions
 
@@ -69,4 +86,7 @@ defmodule OpenApiSpex.Cast.AnyOf do
     end
     |> Enum.join(", ")
   end
+
+  defp value_if_not_casted(:__not_casted, value), do: value
+  defp value_if_not_casted(value, _), do: value
 end

lib/open_api_spex/cast/discriminator.ex

@@ -40,18 +40,14 @@ defmodule OpenApiSpex.Cast.Discriminator do
   defp cast_discriminator(%_{value: value, schema: schema} = ctx) do
     {discriminator_property, mappings} = discriminator_details(schema)
 
-    case Map.pop(value, "#{discriminator_property}") do
-      {"", _} ->
+    case value["#{discriminator_property}"] || value[discriminator_property] do
+      v when v in ["", nil] ->
         error(:no_value_for_discriminator, ctx)
 
-      {discriminator_value, _castable_value} ->
+      discriminator_value ->
         # The cast specified by the composite key (allOf, anyOf, oneOf) MUST succeed
         # or return an error according to the Open API Spec.
-        composite_ctx = %{
-          ctx
-          | schema: %{schema | discriminator: nil},
-            path: ["#{discriminator_property}" | ctx.path]
-        }
+        composite_ctx = %{ctx | schema: %{schema | discriminator: nil}}
 
         cast_composition(composite_ctx, ctx, discriminator_value, mappings)
     end
@@ -60,7 +56,12 @@ defmodule OpenApiSpex.Cast.Discriminator do
   defp cast_composition(composite_ctx, ctx, discriminator_value, mappings) do
     with {composite_schemas, cast_composition_result} <- cast_composition(composite_ctx),
          {:ok, _} <- cast_composition_result,
-         %{} = schema <- find_discriminator_schema(discriminator_value, mappings, composite_schemas) do
+         %{} = schema <-
+           find_discriminator_schema(
+             discriminator_value,
+             mappings,
+             composite_schemas
+           ) do
       Cast.cast(%{composite_ctx | schema: schema})
     else
       nil -> error(:invalid_discriminator_value, ctx)
@@ -93,7 +94,11 @@ defmodule OpenApiSpex.Cast.Discriminator do
     end
   end
 
-  defp find_discriminator_schema(discriminator, _, schemas) do
+  defp find_discriminator_schema(discriminator, _, schemas) when is_atom(discriminator) do
+    Enum.find(schemas, &Kernel.==(&1."x-struct", discriminator))
+  end
+
+  defp find_discriminator_schema(discriminator, _, schemas) when is_binary(discriminator) do
     Enum.find(schemas, &Kernel.==(&1.title, discriminator))
   end
 

lib/open_api_spex/cast/object.ex

@@ -1,7 +1,7 @@
 defmodule OpenApiSpex.Cast.Object do
   @moduledoc false
   alias OpenApiSpex.Cast
-  alias OpenApiSpex.Cast.Error
+  alias OpenApiSpex.Cast.Utils
   alias OpenApiSpex.Reference
 
   def cast(%{value: value} = ctx) when not is_map(value) do
@@ -22,7 +22,7 @@ defmodule OpenApiSpex.Cast.Object do
          value = cast_atom_keys(value, resolved_schema_properties),
          ctx = %{ctx | value: value},
          {:ok, ctx} <- cast_additional_properties(ctx, original_value),
-         :ok <- check_required_fields(ctx, schema),
+         :ok <- Utils.check_required_fields(ctx),
          :ok <- check_max_properties(ctx),
          :ok <- check_min_properties(ctx),
          {:ok, value} <- cast_properties(%{ctx | schema: resolved_schema_properties}) do
@@ -70,35 +70,6 @@ defmodule OpenApiSpex.Cast.Object do
     end
   end
 
-  defp check_required_fields(%{value: input_map} = ctx, schema) do
-    required = schema.required || []
-
-    # Adjust required fields list, based on read_write_scope
-    required =
-      Enum.filter(required, fn key ->
-        case {ctx.read_write_scope, schema.properties[key]} do
-          {:read, %{writeOnly: true}} -> false
-          {:write, %{readOnly: true}} -> false
-          _ -> true
-        end
-      end)
-
-    input_keys = Map.keys(input_map)
-    missing_keys = required -- input_keys
-
-    if missing_keys == [] do
-      :ok
-    else
-      errors =
-        Enum.map(missing_keys, fn key ->
-          ctx = %{ctx | path: [key | ctx.path]}
-          Error.new(ctx, {:missing_field, key})
-        end)
-
-      {:error, ctx.errors ++ errors}
-    end
-  end
-
   defp check_max_properties(%{schema: %{maxProperties: max_properties}} = ctx)
        when is_integer(max_properties) do
     count = ctx.value |> Map.keys() |> length()

lib/open_api_spex/cast/one_of.ex

@@ -1,6 +1,7 @@
 defmodule OpenApiSpex.Cast.OneOf do
   @moduledoc false
   alias OpenApiSpex.Cast
+  alias OpenApiSpex.Cast.Utils
   alias OpenApiSpex.Schema
 
   def cast(%_{schema: %{type: _, oneOf: []}} = ctx) do
@@ -9,20 +10,24 @@ defmodule OpenApiSpex.Cast.OneOf do
 
   def cast(%{schema: %{type: _, oneOf: schemas}} = ctx) do
     castable_schemas =
-      Enum.reduce(schemas, {[], []}, fn schema, {results, error_schemas} ->
+      Enum.reduce(schemas, {ctx, [], []}, fn schema, {ctx, results, error_schemas} ->
         schema = OpenApiSpex.resolve_schema(schema, ctx.schemas)
+        relaxed_schema = %{schema | "x-struct": nil}
 
-        case Cast.cast(%{ctx | schema: schema}) do
-          {:ok, value} -> {[{:ok, value, schema} | results], error_schemas}
-          _error -> {results, [schema | error_schemas]}
+        with {:ok, value} <- Cast.cast(%{ctx | errors: [], schema: relaxed_schema}),
+             :ok <- Utils.check_required_fields(ctx, value) do
+          {ctx, [{:ok, value, schema} | results], error_schemas}
+        else
+          {:error, errors} ->
+            {%Cast{ctx | errors: ctx.errors ++ errors}, results, [schema | error_schemas]}
         end
       end)
 
     case castable_schemas do
-      {[{:ok, %_{} = value, _}], _} -> {:ok, value}
-      {[{:ok, value, %Schema{"x-struct": nil}}], _} -> {:ok, value}
-      {[{:ok, value, %Schema{"x-struct": module}}], _} -> {:ok, struct(module, value)}
-      {success_results, failed_schemas} -> error(ctx, success_results, failed_schemas)
+      {_, [{:ok, %_{} = value, _}], _} -> {:ok, value}
+      {_, [{:ok, value, %Schema{"x-struct": nil}}], _} -> {:ok, value}
+      {_, [{:ok, value, %Schema{"x-struct": module}}], _} -> {:ok, struct(module, value)}
+      {ctx, success_results, failed_schemas} -> error(ctx, success_results, failed_schemas)
     end
   end