fix: feedback

Author: tore-statsig

Diff for: lib/statsig.ex

@@ -67,6 +67,7 @@ defmodule Statsig do
 
   defp log_exposures(%User{} = user, %EvaluationResult{} = result, type) do
     [primary | secondary] = result.exposures
+
     event =
       base_event(user, secondary, type)
       |> Map.put(:metadata, primary)

Diff for: lib/statsig/evaluator.ex

@@ -425,32 +425,35 @@ defmodule Statsig.Evaluator do
     hash
   end
 
-  defp get_user_id(%User{userID: id}, "userID"), do: to_string(id)
+  defp get_user_id(%User{} = user, "userID"), do: to_string(user.user_id)
 
-  defp get_user_id(%User{customIDs: custom_ids}, prop),
-    do: try_get_with_lower(custom_ids, prop) |> to_string()
+  defp get_user_id(%User{} = user, prop),
+    do: try_get_with_lower(user.custom_ids || %{}, prop) |> to_string()
 
   defp get_user_field(%User{} = user, prop) do
     case try_get_with_lower(%{
-      user.userID => user.userID,
+      user.userID => user.user_id,
       "email" => user.email,
       "ip" => user.ip,
-      "userAgent" => user.userAgent,
+      "userAgent" => user.user_agent,
       "country" => user.country,
       "locale" => user.locale,
-      "appVersion" => user.appVersion
+      "appVersion" => user.app_version
     }, prop) do
       nil -> try_get_with_lower(user.custom || %{}, prop)
       found -> found
     end
     |> case do
-      nil -> try_get_with_lower(user.privateAttributes || %{}, prop)
+      nil -> try_get_with_lower(user.private_attributes || %{}, prop)
       found -> found
     end
   end
 
-  defp get_env_field(%User{statsigEnvironment: env}, field) when not is_nil(env),
-    do: try_get_with_lower(env, field) |> to_string()
+  defp get_env_field(%User{} = user, field) do
+    user.statsig_environment
+    |> Map.get(field)
+    |> to_string()
+  end
 
   defp get_env_field(_, _), do: nil
 

Diff for: lib/statsig/user.ex

@@ -1,60 +1,77 @@
 defmodule Statsig.User do
   @derive {Jason.Encoder, only: [
-    :userID,
-    :customIDs,
+    :user_id,
+    :custom_ids,
     :email,
     :ip,
-    :userAgent,
+    :user_agent,
     :country,
     :locale,
-    :appVersion,
+    :app_version,
     :custom,
-    :statsigEnvironment
+    :statsig_environment
   ]}
 
   @type custom_value :: String.t() | number() | boolean() | nil
   @type custom_attributes :: %{optional(String.t()) => custom_value()}
 
   @type t :: %__MODULE__{
-    userID: String.t() | nil,
-    customIDs: %{optional(String.t()) => String.t()} | nil,
+    user_id: String.t() | nil,
+    custom_ids: %{optional(String.t()) => String.t()} | nil,
     email: String.t() | nil,
     ip: String.t() | nil,
-    userAgent: String.t() | nil,
+    user_agent: String.t() | nil,
     country: String.t() | nil,
     locale: String.t() | nil,
-    appVersion: String.t() | nil,
+    app_version: String.t() | nil,
     custom: custom_attributes() | nil,
-    privateAttributes: custom_attributes() | nil,
-    statsigEnvironment: map() | nil
+    private_attributes: custom_attributes() | nil,
+    statsig_environment: map() | nil
   }
 
-  defstruct userID: nil,
-            customIDs: nil,
-            email: nil,
-            ip: nil,
-            userAgent: nil,
-            country: nil,
-            locale: nil,
-            appVersion: nil,
-            custom: nil,
-            privateAttributes: nil,
-            statsigEnvironment: nil
-
-  def new(params \\ %{}) do
-    unless Map.get(params, "userID") || Map.get(params, :userID) ||
-           Map.get(params, "customIDs") || Map.get(params, :customIDs) do
-      raise ArgumentError, "Either userID or customIDs must be provided"
-    end
+  defstruct [
+    :user_id,
+    :custom_ids,
+    :email,
+    :ip,
+    :user_agent,
+    :country,
+    :locale,
+    :app_version,
+    :custom,
+    :private_attributes,
+    :statsig_environment
+  ]
 
-    converted_params = for {key, val} <- params, into: %{} do
-      cond do
-        is_binary(key) -> {String.to_existing_atom(key), val}
-        is_atom(key) -> {key, val}
-        true -> {key, val}
-      end
-    end
+  def new(user_id_or_custom_ids, params \\ [])
 
-    struct(__MODULE__, converted_params)
+  def new(custom_ids = [_ | _], params) do
+    struct(__MODULE__, Keyword.merge(params, custom_ids: custom_ids))
+  end
+
+  def new(user_id, params) when is_binary(user_id) do
+    struct(__MODULE__, Keyword.merge(params, user_id: user_id))
+  end
+
+  def new(_, _), do: raise("You must provide a user id or custom ids")
+
+  defp new_from_params(params) do
+    params =
+      Keyword.new(params, fn
+        {key, _v} = key_and_value when is_atom(key) -> key_and_value
+        {key, value} when is_binary(key) -> {String.to_existing_atom(key), value}
+      end)
+    struct(__MODULE__, params)
+  end
+
+  def encode_as(key) when is_atom(key) do
+    case key do
+      :user_id -> "userID"
+      :custom_ids -> "customIDs"
+      :user_agent -> "userAgent"
+      :app_version -> "appVersion"
+      :statsig_environment -> "statsigEnvironment"
+      _ -> key |> Atom.to_string()
+    end
   end
 end

Diff for: lib/statsig/utils.ex

@@ -1,17 +1,17 @@
 defmodule Statsig.Utils do
   alias Statsig.User
 
-  def get_user_with_env(%User{statsigEnvironment: env} = user) when not is_nil(env),
+  def get_user_with_env(%User{statsig_environment: env} = user) when not is_nil(env),
     do: user
 
-  def get_user_with_env(%User{} = user), do: put_env(user)
+  def get_user_with_env(%User{} = user), do: put_statsig_env(user)
 
-  def sanitize_user(%User{} = user), do: %User{user | privateAttributes: nil}
+  def sanitize_user(%User{} = user), do: %User{user | private_attributes: nil}
 
-  defp put_env(%User{} = user) do
+  defp put_statsig_env(%User{} = user) do
     case Application.get_env(:statsig, :env_tier) do
       nil -> user
-      tier -> %User{user | statsigEnvironment: %{"tier" => tier}}
+      tier -> %User{user | statsig_environment: %{"tier" => tier}}
     end
   end
 end

Diff for: mix.exs

@@ -14,27 +14,25 @@ defmodule Statsig.MixProject do
 
   # Run "mix help compile.app" to learn about applications.
   def application do
-    case Mix.env() do
-      :test ->
-        [extra_applications: [:logger, :jason]]
-      _ ->
-        [
-          mod: {Statsig.Application, []},
-          extra_applications: [:logger, :jason]
-        ]
-    end
+    [
+      mod: {Statsig.Application, []},
+      extra_applications: [:logger]
+    ]
   end
 
   # Specifies which paths to compile per environment.
-  defp elixirc_paths(:test), do: ["lib", "test/support", "test/statsig"]
+  defp elixirc_paths(:test), do: ["lib", "test/support"]
   defp elixirc_paths(_), do: ["lib"]
 
   # Run "mix help deps" to learn about dependencies.
   defp deps do
     [
       {:req, "~> 0.5"},
-      {:jason, "~> 1.2"},
       {:ua_parser, "~> 1.8"}
     ]
   end
+
+  defp aliases() do
+    [test: "test --no-start"]
+  end
 end

Diff for: test/statsig/user_test.exs

@@ -3,75 +3,77 @@ defmodule Statsig.UserTest do
 
   alias Statsig.User
 
-  describe "new/1" do
-    test "accepts userID as string key" do
-      user = User.new(%{"userID" => "123"})
-      assert user.userID == "123"
+  describe "new/2" do
+    test "accepts string user_id as first argument" do
+      user = User.new("123")
+      assert user.user_id == "123"
     end
 
-    test "accepts userID as atom key" do
-      user = User.new(%{userID: "123"})
-      assert user.userID == "123"
+    test "accepts string user_id with additional params" do
+      user = User.new("123", email: "[email protected]")
+      assert user.user_id == "123"
+      assert user.email == "[email protected]"
     end
 
-    test "accepts customIDs as string key" do
-      user = User.new(%{"customIDs" => %{"employee_id" => "456"}})
-      assert user.customIDs == %{"employee_id" => "456"}
+    test "accepts custom_ids list as first argument" do
+      user = User.new([employee_id: "456"])
+      assert user.custom_ids == [employee_id: "456"]
     end
 
-    test "accepts customIDs as atom key" do
-      user = User.new(%{customIDs: %{"employee_id" => "456"}})
-      assert user.customIDs == %{"employee_id" => "456"}
+    test "accepts custom_ids with additional params" do
+      user = User.new([employee_id: "456"], email: "[email protected]")
+      assert user.custom_ids == [employee_id: "456"]
+      assert user.email == "[email protected]"
     end
 
-    test "raises when neither userID nor customIDs is provided" do
-      assert_raise ArgumentError, "Either userID or customIDs must be provided", fn ->
-        User.new(%{email: "[email protected]"})
+    test "raises when neither user_id nor custom_ids is provided" do
+      assert_raise RuntimeError, "You must provide a user id or custom ids", fn ->
+        User.new(%{})
       end
     end
   end
 
   describe "JSON serialization" do
-    test "excludes privateAttributes when encoding to JSON" do
+    test "excludes private_attributes when encoding to JSON" do
       user = User.new(%{
-        "userID" => "123",
+        "user_id" => "123",
         "email" => "[email protected]",
-        "privateAttributes" => %{"secret" => "value"}
+        "private_attributes" => %{"secret" => "value"}
       })
 
       json = Jason.encode!(user)
       decoded = Jason.decode!(json)
 
-      assert decoded["userID"] == "123"
+      assert decoded["user_id"] == "123"
       assert decoded["email"] == "[email protected]"
-      refute Map.has_key?(decoded, "privateAttributes")
+      refute Map.has_key?(decoded, "private_attributes")
     end
 
     test "includes all other fields when encoding to JSON" do
       user = User.new(%{
-        "userID" => "123",
+        "user_id" => "123",
         "email" => "[email protected]",
         "custom" => %{"is_employee" => true},
-        "customIDs" => %{"employee_id" => "456"},
+        "custom_ids" => [employee_id: "456"],
         "ip" => "1.2.3.4",
-        "userAgent" => "Mozilla",
+        "user_agent" => "Mozilla",
         "country" => "US",
         "locale" => "en-US",
-        "appVersion" => "1.0.0"
+        "app_version" => "1.0.0"
       })
 
       json = Jason.encode!(user)
       decoded = Jason.decode!(json)
 
-      assert decoded["userID"] == "123"
+      assert decoded["user_id"] == "123"
       assert decoded["email"] == "[email protected]"
       assert decoded["custom"] == %{"is_employee" => true}
-      assert decoded["customIDs"] == %{"employee_id" => "456"}
+      assert decoded["custom_ids"] == %{"employee_id" => "456"}
       assert decoded["ip"] == "1.2.3.4"
-      assert decoded["userAgent"] == "Mozilla"
+      assert decoded["user_agent"] == "Mozilla"
       assert decoded["country"] == "US"
       assert decoded["locale"] == "en-US"
-      assert decoded["appVersion"] == "1.0.0"
+      assert decoded["app_version"] == "1.0.0"
     end
   end
 end