use ecto type instead

Author: filipecabaco

lib/realtime_web/channels/payloads/broadcast.ex

@@ -5,17 +5,15 @@ defmodule RealtimeWeb.Channels.Payloads.Broadcast do
   use Ecto.Schema
   import Ecto.Changeset
   alias RealtimeWeb.Channels.Payloads.Join
-  alias RealtimeWeb.Channels.Payloads.ChangesetNormalizer
+  alias RealtimeWeb.Channels.Payloads.FlexibleBoolean
 
   embedded_schema do
-    field :ack, :boolean, default: false
-    field :self, :boolean, default: false
+    field :ack, FlexibleBoolean, default: false
+    field :self, FlexibleBoolean, default: false
     embeds_one :replay, RealtimeWeb.Channels.Payloads.Broadcast.Replay
   end
 
   def changeset(broadcast, attrs) do
-    attrs = ChangesetNormalizer.normalize_boolean_fields(attrs, [:ack, :self])
-
     broadcast
     |> cast(attrs, [:ack, :self], message: &Join.error_message/2)
     |> cast_embed(:replay, invalid_message: "unable to parse, expected a map")

lib/realtime_web/channels/payloads/changeset_normalizer.ex

@@ -8,13 +8,13 @@ defmodule RealtimeWeb.Channels.Payloads.Config do
   alias RealtimeWeb.Channels.Payloads.Broadcast
   alias RealtimeWeb.Channels.Payloads.Presence
   alias RealtimeWeb.Channels.Payloads.PostgresChange
-  alias RealtimeWeb.Channels.Payloads.ChangesetNormalizer
+  alias RealtimeWeb.Channels.Payloads.FlexibleBoolean
 
   embedded_schema do
     embeds_one :broadcast, Broadcast
     embeds_one :presence, Presence
     embeds_many :postgres_changes, PostgresChange
-    field :private, :boolean, default: false
+    field :private, FlexibleBoolean, default: false
   end
 
   def changeset(config, attrs) do
@@ -25,7 +25,6 @@ defmodule RealtimeWeb.Channels.Payloads.Config do
         {k, v} -> {k, v}
       end)
       |> Map.new()
-      |> ChangesetNormalizer.normalize_boolean_fields([:private])
 
     config
     |> cast(attrs, [:private], message: &Join.error_message/2)

lib/realtime_web/channels/payloads/config.ex

@@ -0,0 +1,35 @@
+defmodule RealtimeWeb.Channels.Payloads.FlexibleBoolean do
+  @moduledoc """
+  Custom Ecto type that handles boolean values coming as strings.
+
+  Accepts:
+  - Boolean values (true/false) - used as-is
+  - Strings "true", "True", "TRUE", etc. - cast to true
+  - Strings "false", "False", "FALSE", etc. - cast to false
+  - Any other value - returns error
+  """
+  use Ecto.Type
+
+  @impl true
+  def type, do: :boolean
+
+  @impl true
+  def cast(value) when is_boolean(value), do: {:ok, value}
+
+  def cast(value) when is_binary(value) do
+    case String.downcase(value) do
+      "true" -> {:ok, true}
+      "false" -> {:ok, false}
+      _ -> :error
+    end
+  end
+
+  def cast(_), do: :error
+
+  @impl true
+  def load(value), do: {:ok, value}
+
+  @impl true
+  def dump(value) when is_boolean(value), do: {:ok, value}
+  def dump(_), do: :error
+end

lib/realtime_web/channels/payloads/flexible_boolean.ex

@@ -52,7 +52,10 @@ defmodule RealtimeWeb.Channels.Payloads.Join do
     type = Keyword.get(meta, :type)
 
     if type,
-      do: "unable to parse, expected #{type}",
+      do: "unable to parse, expected #{format_type(type)}",
       else: "unable to parse"
   end
+
+  defp format_type(RealtimeWeb.Channels.Payloads.FlexibleBoolean), do: :boolean
+  defp format_type(type), do: type
 end

lib/realtime_web/channels/payloads/join.ex

@@ -5,16 +5,14 @@ defmodule RealtimeWeb.Channels.Payloads.Presence do
   use Ecto.Schema
   import Ecto.Changeset
   alias RealtimeWeb.Channels.Payloads.Join
-  alias RealtimeWeb.Channels.Payloads.ChangesetNormalizer
+  alias RealtimeWeb.Channels.Payloads.FlexibleBoolean
 
   embedded_schema do
-    field :enabled, :boolean, default: true
+    field :enabled, FlexibleBoolean, default: true
     field :key, :any, default: UUID.uuid1(), virtual: true
   end
 
   def changeset(presence, attrs) do
-    attrs = ChangesetNormalizer.normalize_boolean_fields(attrs, [:enabled])
-
     cast(presence, attrs, [:enabled, :key], message: &Join.error_message/2)
   end
 end

lib/realtime_web/channels/payloads/presence.ex

@@ -0,0 +1,72 @@
+defmodule RealtimeWeb.Channels.Payloads.FlexibleBooleanTest do
+  use ExUnit.Case, async: true
+
+  alias RealtimeWeb.Channels.Payloads.FlexibleBoolean
+
+  describe "type/0" do
+    test "returns :boolean" do
+      assert FlexibleBoolean.type() == :boolean
+    end
+  end
+
+  describe "cast/1" do
+    test "casts boolean true as-is" do
+      assert FlexibleBoolean.cast(true) == {:ok, true}
+    end
+
+    test "casts boolean false as-is" do
+      assert FlexibleBoolean.cast(false) == {:ok, false}
+    end
+
+    test "casts string 'true' in any case to boolean true" do
+      assert FlexibleBoolean.cast("true") == {:ok, true}
+      assert FlexibleBoolean.cast("True") == {:ok, true}
+      assert FlexibleBoolean.cast("TRUE") == {:ok, true}
+      assert FlexibleBoolean.cast("tRuE") == {:ok, true}
+    end
+
+    test "casts string 'false' in any case to boolean false" do
+      assert FlexibleBoolean.cast("false") == {:ok, false}
+      assert FlexibleBoolean.cast("False") == {:ok, false}
+      assert FlexibleBoolean.cast("FALSE") == {:ok, false}
+      assert FlexibleBoolean.cast("fAlSe") == {:ok, false}
+    end
+
+    test "returns error for invalid string values" do
+      assert FlexibleBoolean.cast("test") == :error
+      assert FlexibleBoolean.cast("yes") == :error
+      assert FlexibleBoolean.cast("no") == :error
+      assert FlexibleBoolean.cast("1") == :error
+      assert FlexibleBoolean.cast("0") == :error
+      assert FlexibleBoolean.cast("") == :error
+    end
+
+    test "returns error for non-boolean, non-string values" do
+      assert FlexibleBoolean.cast(1) == :error
+      assert FlexibleBoolean.cast(0) == :error
+      assert FlexibleBoolean.cast(nil) == :error
+      assert FlexibleBoolean.cast(%{}) == :error
+      assert FlexibleBoolean.cast([]) == :error
+    end
+  end
+
+  describe "load/1" do
+    test "loads boolean values" do
+      assert FlexibleBoolean.load(true) == {:ok, true}
+      assert FlexibleBoolean.load(false) == {:ok, false}
+    end
+  end
+
+  describe "dump/1" do
+    test "dumps boolean values" do
+      assert FlexibleBoolean.dump(true) == {:ok, true}
+      assert FlexibleBoolean.dump(false) == {:ok, false}
+    end
+
+    test "returns error for non-boolean values" do
+      assert FlexibleBoolean.dump("true") == :error
+      assert FlexibleBoolean.dump(1) == :error
+      assert FlexibleBoolean.dump(nil) == :error
+    end
+  end
+end