fix: normalize booleans on join payloads

To ensure better compatibility with existing users we will infer intent from non boolean values by normalizing and downcasing boolean strings

e.g. False will be considered false boolean value

Author: filipecabaco

lib/realtime_web/channels/payloads/broadcast.ex

@@ -5,6 +5,7 @@ defmodule RealtimeWeb.Channels.Payloads.Broadcast do
   use Ecto.Schema
   import Ecto.Changeset
   alias RealtimeWeb.Channels.Payloads.Join
+  alias RealtimeWeb.Channels.Payloads.ChangesetNormalizer
 
   embedded_schema do
     field :ack, :boolean, default: false
@@ -13,7 +14,10 @@ defmodule RealtimeWeb.Channels.Payloads.Broadcast do
   end
 
   def changeset(broadcast, attrs) do
-    cast(broadcast, attrs, [:ack, :self], message: &Join.error_message/2)
+    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")
   end
 end

lib/realtime_web/channels/payloads/changeset_normalizer.ex

@@ -0,0 +1,48 @@
+defmodule RealtimeWeb.Channels.Payloads.ChangesetNormalizer do
+  @moduledoc """
+  Functions for normalizing changeset attributes before validation.
+  Handles conversion of string boolean representations to actual booleans.
+  """
+
+  @doc """
+  Normalizes a value that should be a boolean. Accepts:
+  - Boolean values (true/false) - returned as-is
+  - Strings "true", "True", "TRUE", etc. - converted to true
+  - Strings "false", "False", "FALSE", etc. - converted to false
+  - Any other value - returned as-is (will fail validation later)
+  """
+  def normalize_boolean(value) when is_boolean(value), do: value
+
+  def normalize_boolean(value) when is_binary(value) do
+    case String.downcase(value) do
+      "true" -> true
+      "false" -> false
+      _ -> value
+    end
+  end
+
+  def normalize_boolean(value), do: value
+
+  @doc """
+  Normalizes boolean fields in an attrs map for the given field names.
+  """
+  def normalize_boolean_fields(attrs, field_names) when is_map(attrs) do
+    Enum.reduce(field_names, attrs, fn field_name, acc ->
+      field_key_string = to_string(field_name)
+      field_key_atom = field_name
+
+      acc
+      |> maybe_normalize_field(field_key_string)
+      |> maybe_normalize_field(field_key_atom)
+    end)
+  end
+
+  def normalize_boolean_fields(attrs, _field_names), do: attrs
+
+  defp maybe_normalize_field(attrs, key) do
+    case Map.fetch(attrs, key) do
+      {:ok, value} -> Map.put(attrs, key, normalize_boolean(value))
+      :error -> attrs
+    end
+  end
+end

lib/realtime_web/channels/payloads/config.ex

@@ -8,6 +8,7 @@ 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
 
   embedded_schema do
     embeds_one :broadcast, Broadcast
@@ -24,6 +25,7 @@ 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/presence.ex

@@ -5,13 +5,16 @@ defmodule RealtimeWeb.Channels.Payloads.Presence do
   use Ecto.Schema
   import Ecto.Changeset
   alias RealtimeWeb.Channels.Payloads.Join
+  alias RealtimeWeb.Channels.Payloads.ChangesetNormalizer
 
   embedded_schema do
     field :enabled, :boolean, 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

mix.exs

@@ -4,7 +4,7 @@ defmodule Realtime.MixProject do
   def project do
     [
       app: :realtime,
-      version: "2.73.5",
+      version: "2.73.6",
       elixir: "~> 1.18",
       elixirc_paths: elixirc_paths(Mix.env()),
       start_permanent: Mix.env() == :prod,

test/realtime_web/channels/payloads/changeset_normalizer_test.exs

@@ -0,0 +1,106 @@
+defmodule RealtimeWeb.Channels.Payloads.ChangesetNormalizerTest do
+  use ExUnit.Case, async: true
+
+  alias RealtimeWeb.Channels.Payloads.ChangesetNormalizer
+
+  describe "normalize_boolean/1" do
+    test "returns true for boolean true" do
+      assert ChangesetNormalizer.normalize_boolean(true) == true
+    end
+
+    test "returns false for boolean false" do
+      assert ChangesetNormalizer.normalize_boolean(false) == false
+    end
+
+    test "converts string 'true' in any case to boolean true" do
+      assert ChangesetNormalizer.normalize_boolean("true") == true
+      assert ChangesetNormalizer.normalize_boolean("True") == true
+      assert ChangesetNormalizer.normalize_boolean("TRUE") == true
+    end
+
+    test "converts string 'false' in any case to boolean false" do
+      assert ChangesetNormalizer.normalize_boolean("false") == false
+      assert ChangesetNormalizer.normalize_boolean("False") == false
+      assert ChangesetNormalizer.normalize_boolean("FALSE") == false
+    end
+
+    test "returns other string values as-is" do
+      assert ChangesetNormalizer.normalize_boolean("test") == "test"
+      assert ChangesetNormalizer.normalize_boolean(1) == 1
+      assert ChangesetNormalizer.normalize_boolean(nil) == nil
+      assert ChangesetNormalizer.normalize_boolean(%{}) == %{}
+      assert ChangesetNormalizer.normalize_boolean([]) == []
+    end
+  end
+
+  describe "normalize_boolean_fields/2" do
+    test "normalizes boolean fields with string keys" do
+      attrs = %{"enabled" => "true", "ack" => "false"}
+      result = ChangesetNormalizer.normalize_boolean_fields(attrs, [:enabled, :ack])
+
+      assert result == %{"enabled" => true, "ack" => false}
+    end
+
+    test "normalizes boolean fields with atom keys" do
+      attrs = %{enabled: "True", ack: "False"}
+      result = ChangesetNormalizer.normalize_boolean_fields(attrs, [:enabled, :ack])
+
+      assert result == %{enabled: true, ack: false}
+    end
+
+    test "normalizes mixed string and atom keys" do
+      attrs = %{"enabled" => "true", :ack => "false"}
+      result = ChangesetNormalizer.normalize_boolean_fields(attrs, [:enabled, :ack])
+
+      assert result == %{"enabled" => true, :ack => false}
+    end
+
+    test "leaves non-boolean fields unchanged" do
+      attrs = %{"enabled" => "true", "name" => "test", "count" => 42}
+      result = ChangesetNormalizer.normalize_boolean_fields(attrs, [:enabled])
+
+      assert result == %{"enabled" => true, "name" => "test", "count" => 42}
+    end
+
+    test "leaves fields not in the list unchanged" do
+      attrs = %{"enabled" => "true", "other" => "false"}
+      result = ChangesetNormalizer.normalize_boolean_fields(attrs, [:enabled])
+
+      assert result == %{"enabled" => true, "other" => "false"}
+    end
+
+    test "handles missing fields gracefully" do
+      attrs = %{"name" => "test"}
+      result = ChangesetNormalizer.normalize_boolean_fields(attrs, [:enabled, :ack])
+
+      assert result == %{"name" => "test"}
+    end
+
+    test "handles actual boolean values without changing them" do
+      attrs = %{"enabled" => true, "ack" => false}
+      result = ChangesetNormalizer.normalize_boolean_fields(attrs, [:enabled, :ack])
+
+      assert result == %{"enabled" => true, "ack" => false}
+    end
+
+    test "leaves invalid boolean strings as-is for validation to catch" do
+      attrs = %{"enabled" => "invalid", "ack" => "test"}
+      result = ChangesetNormalizer.normalize_boolean_fields(attrs, [:enabled, :ack])
+
+      assert result == %{"enabled" => "invalid", "ack" => "test"}
+    end
+
+    test "returns non-map values as-is" do
+      assert ChangesetNormalizer.normalize_boolean_fields("not a map", [:enabled]) == "not a map"
+      assert ChangesetNormalizer.normalize_boolean_fields(nil, [:enabled]) == nil
+      assert ChangesetNormalizer.normalize_boolean_fields([], [:enabled]) == []
+    end
+
+    test "handles empty field list" do
+      attrs = %{"enabled" => "true"}
+      result = ChangesetNormalizer.normalize_boolean_fields(attrs, [])
+
+      assert result == %{"enabled" => "true"}
+    end
+  end
+end

test/realtime_web/channels/payloads/join_test.exs

@@ -119,5 +119,100 @@ defmodule RealtimeWeb.Channels.Payloads.JoinTest do
 
       assert {:ok, %Join{config: %Config{postgres_changes: []}}} = Join.validate(config)
     end
+
+    test "accepts string 'true' for boolean fields" do
+      config = %{
+        "config" => %{
+          "private" => "true",
+          "broadcast" => %{"ack" => "true", "self" => "true"},
+          "presence" => %{"enabled" => "true"}
+        }
+      }
+
+      assert {:ok, %Join{config: config_result}} = Join.validate(config)
+
+      assert %Config{
+               private: true,
+               broadcast: %Broadcast{ack: true, self: true},
+               presence: %Presence{enabled: true}
+             } = config_result
+    end
+
+    test "accepts string 'True' for boolean fields" do
+      config = %{
+        "config" => %{
+          "private" => "True",
+          "broadcast" => %{"ack" => "True", "self" => "True"},
+          "presence" => %{"enabled" => "True"}
+        }
+      }
+
+      assert {:ok, %Join{config: config_result}} = Join.validate(config)
+
+      assert %Config{
+               private: true,
+               broadcast: %Broadcast{ack: true, self: true},
+               presence: %Presence{enabled: true}
+             } = config_result
+    end
+
+    test "accepts string 'false' for boolean fields" do
+      config = %{
+        "config" => %{
+          "private" => "false",
+          "broadcast" => %{"ack" => "false", "self" => "false"},
+          "presence" => %{"enabled" => "false"}
+        }
+      }
+
+      assert {:ok, %Join{config: config_result}} = Join.validate(config)
+
+      assert %Config{
+               private: false,
+               broadcast: %Broadcast{ack: false, self: false},
+               presence: %Presence{enabled: false}
+             } = config_result
+    end
+
+    test "accepts string 'False' for boolean fields" do
+      config = %{
+        "config" => %{
+          "private" => "False",
+          "broadcast" => %{"ack" => "False", "self" => "False"},
+          "presence" => %{"enabled" => "False"}
+        }
+      }
+
+      assert {:ok, %Join{config: config_result}} = Join.validate(config)
+
+      assert %Config{
+               private: false,
+               broadcast: %Broadcast{ack: false, self: false},
+               presence: %Presence{enabled: false}
+             } = config_result
+    end
+
+    test "rejects invalid boolean strings" do
+      config = %{
+        "config" => %{
+          "private" => "yes",
+          "broadcast" => %{"ack" => "a", "self" => "b"},
+          "presence" => %{"enabled" => "no"}
+        }
+      }
+
+      assert {:error, :invalid_join_payload, errors} = Join.validate(config)
+
+      assert errors == %{
+               config: %{
+                 private: ["unable to parse, expected boolean"],
+                 broadcast: %{
+                   ack: ["unable to parse, expected boolean"],
+                   self: ["unable to parse, expected boolean"]
+                 },
+                 presence: %{enabled: ["unable to parse, expected boolean"]}
+               }
+             }
+    end
   end
 end