feat: Extract FF handling to separate class

Author: rafaeelaudibert

lib/posthog/client.ex

@@ -273,42 +273,8 @@ defmodule Posthog.Client do
       |> Enum.reduce(%{distinct_id: distinct_id}, fn {k, v}, acc -> Map.put(acc, k, v) end)
 
     case post!("/decide?v=4", body, headers(opts[:headers])) do
-      {:ok, %{body: body}} ->
-        if Map.has_key?(body, "flags") do
-          flags = body["flags"]
-
-          feature_flags =
-            Map.new(flags, fn {k, v} ->
-              {k, if(v["variant"], do: v["variant"], else: v["enabled"])}
-            end)
-
-          feature_flag_payloads =
-            Map.new(flags, fn {k, v} ->
-              {k,
-               if(v["metadata"]["payload"],
-                 do: decode_feature_flag_payload(v["metadata"]["payload"]),
-                 else: nil
-               )}
-            end)
-
-          {:ok,
-           %{
-             flags: flags,
-             feature_flags: feature_flags,
-             feature_flag_payloads: feature_flag_payloads,
-             request_id: body["requestId"]
-           }}
-        else
-          {:ok,
-           %{
-             feature_flags: Map.get(body, "featureFlags", %{}),
-             feature_flag_payloads: decode_feature_flag_payloads(body),
-             request_id: body["requestId"]
-           }}
-        end
-
-      err ->
-        err
+      {:ok, %{body: body}} -> {:ok, Posthog.FeatureFlag.process_response(body)}
+      err -> err
     end
   end
 
@@ -396,19 +362,4 @@ defmodule Posthog.Client do
       "$lib_version" => @lib_version
     }
   end
-
-  defp decode_feature_flag_payloads(data) do
-    data
-    |> Map.get("featureFlagPayloads", %{})
-    |> Enum.reduce(%{}, fn {k, v}, map ->
-      Map.put(map, k, decode_feature_flag_payload(v))
-    end)
-  end
-
-  defp decode_feature_flag_payload(payload) do
-    case Jason.decode(payload) do
-      {:ok, decoded} -> decoded
-      {:error, _} -> payload
-    end
-  end
 end

lib/posthog/feature_flag.ex

@@ -104,4 +104,140 @@ defmodule Posthog.FeatureFlag do
   """
   @spec boolean?(t()) :: boolean()
   def boolean?(%__MODULE__{enabled: value}), do: is_boolean(value)
+
+  @doc """
+  Processes a feature flag response from the PostHog API.
+  Handles both v3 and v4 API response formats.
+
+  ## Parameters
+
+    * `response` - The raw response from the API
+
+  ## Examples
+
+      # v4 API response
+      response = %{
+        "flags" => %{
+          "my-flag" => %{
+            "enabled" => true,
+            "variant" => nil,
+            "metadata" => %{"payload" => "{\"color\": \"blue\"}"}
+          }
+        },
+        "requestId" => "123"
+      }
+      Posthog.FeatureFlag.process_response(response)
+      # Returns: %{
+      #   flags: %{"my-flag" => %{"enabled" => true, "variant" => nil, "metadata" => %{"payload" => "{\"color\": \"blue\"}"}}},
+      #   feature_flags: %{"my-flag" => true},
+      #   feature_flag_payloads: %{"my-flag" => %{"color" => "blue"}},
+      #   request_id: "123"
+      # }
+
+      # v3 API response
+      response = %{
+        "featureFlags" => %{"my-flag" => true},
+        "featureFlagPayloads" => %{"my-flag" => "{\"color\": \"blue\"}"},
+        "requestId" => "123"
+      }
+      Posthog.FeatureFlag.process_response(response)
+      # Returns: %{
+      #   feature_flags: %{"my-flag" => true},
+      #   feature_flag_payloads: %{"my-flag" => %{"color" => "blue"}},
+      #   request_id: "123"
+      # }
+  """
+  @spec process_response(map()) :: %{
+          flags: map() | nil,
+          feature_flags: %{optional(binary()) => variant()},
+          feature_flag_payloads: %{optional(binary()) => term()},
+          request_id: binary() | nil
+        }
+  def process_response(%{"flags" => flags} = response) do
+    feature_flags =
+      Map.new(flags, fn {k, v} ->
+        {k, if(v["variant"], do: v["variant"], else: v["enabled"])}
+      end)
+
+    feature_flag_payloads =
+      Map.new(flags, fn {k, v} ->
+        {k,
+         if(v["metadata"]["payload"],
+           do: decode_payload(v["metadata"]["payload"]),
+           else: nil
+         )}
+      end)
+
+    %{
+      flags: flags,
+      feature_flags: feature_flags,
+      feature_flag_payloads: feature_flag_payloads,
+      request_id: response["requestId"]
+    }
+  end
+
+  def process_response(response) do
+    %{
+      flags: nil,
+      feature_flags: Map.get(response, "featureFlags", %{}),
+      feature_flag_payloads: decode_payloads(Map.get(response, "featureFlagPayloads", %{})),
+      request_id: response["requestId"]
+    }
+  end
+
+  @doc """
+  Decodes a map of feature flag payloads.
+
+  ## Parameters
+
+    * `payloads` - Map of feature flag names to their payload values
+
+  ## Examples
+
+      payloads = %{
+        "my-flag" => "{\"color\": \"blue\"}",
+        "other-flag" => "plain-text"
+      }
+      Posthog.FeatureFlag.decode_payloads(payloads)
+      # Returns: %{
+      #   "my-flag" => %{"color" => "blue"},
+      #   "other-flag" => "plain-text"
+      # }
+  """
+  @spec decode_payloads(%{optional(binary()) => term()}) :: %{optional(binary()) => term()}
+  def decode_payloads(payloads) do
+    Enum.reduce(payloads, %{}, fn {k, v}, map ->
+      Map.put(map, k, decode_payload(v))
+    end)
+  end
+
+  @doc """
+  Decodes a feature flag payload from JSON string to Elixir term.
+  Returns the original payload if it's not a valid JSON string.
+
+  ## Examples
+
+      # JSON string payload
+      Posthog.FeatureFlag.decode_payload("{\"color\": \"blue\"}")
+      # Returns: %{"color" => "blue"}
+
+      # Non-JSON string payload
+      Posthog.FeatureFlag.decode_payload("plain-text")
+      # Returns: "plain-text"
+
+      # Nil payload
+      Posthog.FeatureFlag.decode_payload(nil)
+      # Returns: nil
+  """
+  @spec decode_payload(term()) :: term()
+  def decode_payload(nil), do: nil
+
+  def decode_payload(payload) when is_binary(payload) do
+    case Posthog.Config.json_library().decode(payload) do
+      {:ok, decoded} -> decoded
+      {:error, _} -> payload
+    end
+  end
+
+  def decode_payload(payload), do: payload
 end