code refactor

Author: JoE11-y

openfeature/providers/elixir-provider/lib/elixir_provider.ex

@@ -1,139 +1,7 @@
 defmodule ElixirProvider do
-  @behaviour OpenFeature.Provider
-
-  alias OpenFeature.ResolutionDetails
-  alias ElixirProvider.GoFeatureFlagOptions
-  alias ElixirProvider.HttpClient
-  alias ElixirProvider.DataCollectorHook
-  alias ElixirProvider.CacheController
-  alias ElixirProvider.ResponseFlagEvaluation
-  alias ElixirProvider.GoFWebSocketClient
-  alias ElixirProvider.RequestFlagEvaluation
-  alias ElixirProvider.ContextTransformer
-  alias ElixirProvider.GofEvaluationContext
-
   @moduledoc """
-  The GO Feature Flag provider for OpenFeature, managing HTTP requests, caching, and flag evaluation.
-  """
-
-  defstruct [
-    :options,
-    :http_client,
-    :data_collector_hook,
-    :ws,
-    :domain
-  ]
-
-  @type t :: %__MODULE__{
-          options: GoFeatureFlagOptions.t(),
-          http_client: HttpClient.t(),
-          data_collector_hook: DataCollectorHook.t() | nil,
-          ws: GoFWebSocketClient.t(),
-          domain: String.t()
-        }
-
-  @impl true
-  def initialize(%__MODULE__{} = provider, domain, _context) do
-    {:ok, http_client} = HttpClient.start_http_connection(provider.options)
-    CacheController.start_link(provider.options)
-    {:ok, data_collector_hook} = DataCollectorHook.start_link(provider.options, http_client)
-    {:ok, ws} = GoFWebSocketClient.start_link(provider.options.endpoint)
-
-    updated_provider = %__MODULE__{
-      provider
-      | domain: domain,
-        http_client: http_client,
-        data_collector_hook: data_collector_hook,
-        ws: ws
-    }
-
-    {:ok, updated_provider}
-  end
-
-  @impl true
-  def shutdown(%__MODULE__{ws: ws} = provider) do
-    Process.exit(ws, :normal)
-    CacheController.clear()
-    if provider.data_collector_hook, do: DataCollectorHook.shutdown(provider.data_collector_hook)
-    :ok
-  end
-
-  @impl true
-  def resolve_boolean_value(provider, key, default, context) do
-    generic_resolve(provider, :boolean, key, default, context)
-  end
-
-  @impl true
-  def resolve_string_value(provider, key, default, context) do
-    generic_resolve(provider, :string, key, default, context)
-  end
-
-  @impl true
-  def resolve_number_value(provider, key, default, context) do
-    generic_resolve(provider, :number, key, default, context)
-  end
-
-  @impl true
-  def resolve_map_value(provider, key, default, context) do
-    generic_resolve(provider, :map, key, default, context)
-  end
-
-  defp generic_resolve(provider, type, flag_key, default_value, context) do
-    {:ok, goff_context} = ContextTransformer.transform_context(context)
-    goff_request = %RequestFlagEvaluation{user: goff_context, default_value: default_value}
-    eval_context_hash = GofEvaluationContext.hash(goff_context)
-
-    response_body =
-      case CacheController.get(flag_key, eval_context_hash) do
-        {:ok, cached_response} ->
-          cached_response
-
-        :miss ->
-          # Fetch from HTTP if cache miss
-          case HttpClient.post(provider.http_client, "/v1/feature/#{flag_key}/eval", goff_request) do
-            {:ok, response} -> handle_response(flag_key, eval_context_hash, response)
-            {:error, reason} -> {:error, {:unexpected_error, reason}}
-          end
-      end
-
-    handle_flag_resolution(response_body, type, flag_key, default_value)
-  end
-
-  defp handle_response(flag_key, eval_context_hash, response) do
-    # Build the flag evaluation struct directly from the response map
-    flag_eval = ResponseFlagEvaluation.decode(response)
-
-    # Cache the response if it's marked as cacheable
-    if flag_eval.cacheable do
-      CacheController.set(flag_key, eval_context_hash, response)
-    end
-
-    {:ok, flag_eval}
-  end
-
-  defp handle_flag_resolution(response, type, flag_key, _default_value) do
-    case response do
-      {:ok, %ResponseFlagEvaluation{value: value, reason: reason}} ->
-        case {type, value} do
-          {:boolean, val} when is_boolean(val) ->
-            {:ok, %ResolutionDetails{value: val, reason: reason}}
-
-          {:string, val} when is_binary(val) ->
-            {:ok, %ResolutionDetails{value: val, reason: reason}}
-
-          {:number, val} when is_number(val) ->
-            {:ok, %ResolutionDetails{value: val, reason: reason}}
-
-          {:map, val} when is_map(val) ->
-            {:ok, %ResolutionDetails{value: val, reason: reason}}
-
-          _ ->
-            {:error, {:variant_not_found, "Expected #{type} but got #{inspect(value)} for flag #{flag_key}"}}
-        end
-
-      _ ->
-        {:error, {:flag_not_found, "Flag #{flag_key} not found"}}
-    end
-  end
+  `ElixirProvider` is a feature flag manager for controlling feature availability in Go applications.
 
+  It allows toggling features dynamically based on configurations from sources like databases and APIs, enabling flexible, real-time control over application behavior.
+  """
 end

openfeature/providers/elixir-provider/lib/provider/application.ex

@@ -0,0 +1,20 @@
+defmodule ElixirProvider.Application do
+  # See https://hexdocs.pm/elixir/Application.html
+  # for more information on OTP Applications
+  @moduledoc false
+
+  use Application
+
+  @impl true
+  def start(_type, _args) do
+    children = [
+      ExSd.ServerSupervisor
+    ]
+
+    # See https://hexdocs.pm/elixir/Supervisor.html
+    # for other strategies and supported options
+    opts = [strategy: :one_for_one, name: ExSd.Supervisor]
+    Supervisor.start_link(children, opts)
+  end
+
+end

openfeature/providers/elixir-provider/lib/provider/cache_controller.ex

@@ -6,10 +6,9 @@ defmodule ElixirProvider.CacheController do
   use GenServer
   @flag_table :flag_cache
 
-  @spec start_link(Keyword.t()) :: GenServer.on_start()
-  def start_link(opts) do
-    name = Keyword.get(opts, :name, __MODULE__)
-    GenServer.start_link(__MODULE__, :ok, name: name)
+  @spec start_link() :: GenServer.on_start()
+  def start_link() do
+    GenServer.start_link(__MODULE__, :ok, name:  __MODULE__)
   end
 
   def get(flag_key, evaluation_hash) do
@@ -27,6 +26,7 @@ defmodule ElixirProvider.CacheController do
   end
 
   def clear do
+    GenServer.stop(__MODULE__)
     :ets.delete_all_objects(@flag_table)
     :ets.insert(@flag_table, {:context, %{}})
     :ok

openfeature/providers/elixir-provider/lib/provider/data_collector_hook.ex

@@ -1,9 +1,9 @@
 defmodule ElixirProvider.DataCollectorHook do
+
   use GenServer
   require Logger
 
   alias ElixirProvider.HttpClient
-  # alias OpenFeature.{EvaluationDetails, HookContext}
   alias ElixirProvider.{FeatureEvent, RequestDataCollector}
 
   @default_targeting_key "undefined-targetingKey"
@@ -25,11 +25,11 @@ defmodule ElixirProvider.DataCollectorHook do
         }
 
   # Starts the GenServer and initializes with options
-  def start_link(options, http_client) do
-    GenServer.start_link(__MODULE__, {options, http_client: http_client}, name: __MODULE__)
+  def start_link() do
+    GenServer.start_link(__MODULE__, [], name: __MODULE__)
   end
 
-  def shutdown(state) do
+  def stop(state) do
     GenServer.stop(__MODULE__)
     collect_data(state.data_flush_interval)
     %__MODULE__{
@@ -41,27 +41,31 @@ defmodule ElixirProvider.DataCollectorHook do
     }
   end
 
-  # Initializes GenServer state and schedules the first flush
-  def init(args) do
+  @impl true
+  def init([]) do
+    {:ok, %__MODULE__{}}
+  end
+
+  # Initializes the state with the provided options
+  def start(options, http_client) do
     state = %__MODULE__{
-      http_client: args.http_client,
-      data_collector_endpoint: args.options.endpoint,
-      disable_data_collection: args.options.disable_data_collection || false,
-      data_flush_interval: args.options.data_flush_interval || 60_000,
+      http_client: http_client,
+      data_collector_endpoint: options.endpoint,
+      disable_data_collection: options.disable_data_collection || false,
+      data_flush_interval: options.data_flush_interval || 60_000,
       event_queue: []
     }
 
     schedule_collect_data(state.data_flush_interval)
     {:ok, state}
   end
 
-  # Schedule periodic flush based on the interval
+  # Schedule periodic data collection based on the interval
   defp schedule_collect_data(interval) do
     Process.send_after(self(), :collect_data, interval)
   end
 
   ### Hook Implementations
-
   def after_hook(hook, hook_context, flag_evaluation_details, _hints) do
     if hook.disable_data_collection or flag_evaluation_details.reason != :CACHED do
       :ok
@@ -76,12 +80,11 @@ defmodule ElixirProvider.DataCollectorHook do
         user_key: Map.get(hook_context.evaluation_context, "targeting_key") || @default_targeting_key
       }
 
-      # Send event to GenServer process to append to queue
       GenServer.cast(__MODULE__, {:add_event, feature_event})
     end
   end
 
-  def error_hook(hook, hook_context, _hints) do
+  def error(hook, hook_context, _hints) do
     if hook.disable_data_collection do
       :ok
     else
@@ -95,24 +98,24 @@ defmodule ElixirProvider.DataCollectorHook do
         user_key: Map.get(hook_context.context, "targeting_key") || @default_targeting_key
       }
 
-      # Send error event to GenServer process to append to queue
       GenServer.call(__MODULE__, {:add_event, feature_event})
     end
   end
 
   ### GenServer Callbacks
-  def handle_call({:add_event, feature_event}, state) do
-    {:noreply, %{state | event_queue: [feature_event | state.event_queue]}}
+  @impl true
+  def handle_call({:add_event, feature_event}, _from, state) do
+    {:reply, :ok, %{state | event_queue: [feature_event | state.event_queue]}}
   end
 
   # Handle the periodic flush
+  @impl true
   def handle_info(:collect_data, state) do
     case collect_data(state) do
       :ok -> Logger.info("Data collected and sent successfully.")
       {:error, reason} -> Logger.error("Failed to send data: #{inspect(reason)}")
     end
 
-    # Schedule the next flush
     schedule_collect_data(state.data_flush_interval)
     {:noreply, %{state | event_queue: []}}
   end