chore: clean up whitespace and improve code readability across multiple files

- Removed unnecessary blank lines and adjusted formatting for consistency in the ApiKey module, ApiKeys context, authentication pipeline, and various controllers and views.
- Enhanced readability in the API key controller and tests by streamlining code structure and ensuring consistent formatting.
- Improved error handling in the API key authentication plug for better clarity and maintainability.

Author: salsabeeljamal

lib/wraft_doc/api_keys/api_key.ex

@@ -25,20 +25,20 @@ defmodule WraftDoc.ApiKeys.ApiKey do
     field(:name, :string)
     field(:key_hash, :string)
     field(:key_prefix, :string)
-    
+
     # Security settings
     field(:expires_at, :utc_datetime)
     field(:is_active, :boolean, default: true)
     field(:rate_limit, :integer, default: 1000)
     field(:ip_whitelist, {:array, :string}, default: [])
-    
+
     # Usage tracking
     field(:last_used_at, :utc_datetime)
     field(:usage_count, :integer, default: 0)
-    
+
     # Additional metadata
     field(:metadata, :map, default: %{})
-    
+
     # Virtual field to store the unhashed key (only available during creation)
     field(:key, :string, virtual: true)
 
@@ -102,8 +102,7 @@ defmodule WraftDoc.ApiKeys.ApiKey do
   Changeset for updating usage statistics.
   """
   def usage_changeset(api_key, attrs \\ %{}) do
-    api_key
-    |> cast(attrs, [:last_used_at, :usage_count])
+    cast(api_key, attrs, [:last_used_at, :usage_count])
   end
 
   # Private functions
@@ -129,7 +128,7 @@ defmodule WraftDoc.ApiKeys.ApiKey do
       prefix = generate_prefix()
       random_part = generate_random_string(32)
       full_key = "wraft_#{prefix}_#{random_part}"
-      
+
       # Hash the key for storage
       key_hash = Bcrypt.hash_pwd_salt(full_key)
 
@@ -144,14 +143,12 @@ defmodule WraftDoc.ApiKeys.ApiKey do
 
   defp generate_prefix do
     # Generate a 8-character prefix for easy identification
-    :crypto.strong_rand_bytes(4)
-    |> Base.encode16(case: :lower)
+    Base.encode16(:crypto.strong_rand_bytes(4), case: :lower)
   end
 
   defp generate_random_string(length) do
-    :crypto.strong_rand_bytes(length)
-    |> Base.url_encode64(padding: false)
-    |> binary_part(0, length)
+    encoded = Base.url_encode64(:crypto.strong_rand_bytes(length), padding: false)
+    binary_part(encoded, 0, length)
   end
 
   @doc """
@@ -182,4 +179,3 @@ defmodule WraftDoc.ApiKeys.ApiKey do
     ip in whitelist
   end
 end
-

lib/wraft_doc/api_keys/api_keys.ex

@@ -3,7 +3,7 @@ defmodule WraftDoc.ApiKeys do
   The ApiKeys context - handles all API key management operations.
   """
   import Ecto.Query
-  
+
   alias WraftDoc.Account.{Role, User}
   alias WraftDoc.ApiKeys.ApiKey
   alias WraftDoc.Documents.InstanceApprovalSystem
@@ -42,7 +42,7 @@ defmodule WraftDoc.ApiKeys do
   def get_api_key_by_key("wraft_" <> rest = full_key) do
     # Extract prefix (first 8 characters after "wraft_")
     prefix = String.slice(rest, 0..7)
-    
+
     # Find all keys with this prefix and check each one
     ApiKey
     |> where([k], k.key_prefix == ^prefix)
@@ -224,7 +224,7 @@ defmodule WraftDoc.ApiKeys do
   @doc """
   Check if rate limit is exceeded for an API key.
   Returns {:ok, api_key} if within limit, {:error, :rate_limit_exceeded} otherwise.
-  
+
   This is a simple hourly rate limit check.
   For production, consider using a more sophisticated rate limiting solution.
   """
@@ -267,4 +267,3 @@ defmodule WraftDoc.ApiKeys do
     end
   end
 end
-

lib/wraft_doc_web/auth/flexible_authpipeline.ex

@@ -1,13 +1,13 @@
 defmodule WraftDocWeb.Guardian.FlexibleAuthPipeline do
   @moduledoc """
   A flexible authentication pipeline that supports both API Key and JWT authentication.
-  
+
   This pipeline:
   1. First attempts API Key authentication (X-API-Key header)
   2. If no API key, falls back to JWT authentication (Authorization: Bearer header)
   3. If either succeeds, sets current_user and current_organisation
   4. If both fail, returns 401 Unauthorized
-  
+
   This allows the same endpoints to work with both authentication methods.
   """
   use Guardian.Plug.Pipeline,
@@ -17,16 +17,15 @@ defmodule WraftDocWeb.Guardian.FlexibleAuthPipeline do
 
   # Try API key authentication first
   plug(WraftDocWeb.Plug.ApiKeyAuth)
-  
+
   # Then try JWT authentication (only if API key didn't succeed)
   plug(Guardian.Plug.VerifyHeader, claims: %{})
   plug(Guardian.Plug.LoadResource, allow_blank: true)
-  
+
   # Load user context (works for both auth methods)
   plug(WraftDocWeb.CurrentUser)
   plug(WraftDocWeb.CurrentOrganisation)
-  
+
   # Finally, ensure we have authentication from either method
   plug(WraftDocWeb.Plug.EnsureAuthenticated)
 end
-

lib/wraft_doc_web/controllers/api_key_controller.ex

@@ -31,7 +31,11 @@ defmodule WraftDocWeb.Api.V1.ApiKeyController do
 
           properties do
             name(:string, "Descriptive name for the API key", required: true)
-            user_id(:string, "User ID for authentication (defaults to current user)", required: false)
+
+            user_id(:string, "User ID for authentication (defaults to current user)",
+              required: false
+            )
+
             expires_at(:string, "Optional: Expiration datetime (ISO-8601)", required: false)
             rate_limit(:integer, "Requests per hour limit", required: false)
             ip_whitelist(:array, "Optional: List of allowed IP addresses", required: false)
@@ -308,4 +312,3 @@ defmodule WraftDocWeb.Api.V1.ApiKeyController do
     end
   end
 end
-

lib/wraft_doc_web/plugs/api_key_auth.ex

@@ -1,18 +1,18 @@
 defmodule WraftDocWeb.Plug.ApiKeyAuth do
   @moduledoc """
   Plug for API Key authentication.
-  
+
   This plug attempts to authenticate requests using an API key from the X-API-Key header.
   If a valid API key is found:
   - Sets conn.assigns.current_user to the user associated with the API key
   - Sets conn.assigns.current_organisation to the organisation
   - Sets conn.assigns.api_key to the API key struct (for audit purposes)
   - Sets conn.assigns.authenticated_via to :api_key
-  
+
   If no API key is provided or invalid, the plug does nothing and lets the
   request continue to the next authentication method (JWT).
   """
-  
+
   import Plug.Conn
   require Logger
 
@@ -52,44 +52,56 @@ defmodule WraftDocWeb.Plug.ApiKeyAuth do
 
     case ApiKeys.verify_api_key(api_key_string, remote_ip) do
       {:ok, %{api_key: api_key, user: user, organisation: organisation}} ->
-        # Check rate limit
-        case ApiKeys.check_rate_limit(api_key) do
-          {:ok, _} ->
-            conn
-            |> assign(:current_user, user)
-            |> assign(:current_organisation, organisation)
-            |> assign(:api_key, api_key)
-            |> assign(:authenticated_via, :api_key)
-
-          {:error, :rate_limit_exceeded} ->
-            Logger.warning("API key rate limit exceeded: #{api_key.id}")
-            send_error_response(conn, 429, "Rate limit exceeded")
-        end
+        handle_rate_limit_check(conn, api_key, user, organisation)
 
-      {:error, :invalid_api_key} ->
-        Logger.warning("Invalid API key provided")
-        send_error_response(conn, 401, "Invalid API key")
+      {:error, error_type} ->
+        handle_authentication_error(conn, error_type)
+    end
+  end
 
-      {:error, :api_key_expired} ->
-        Logger.warning("Expired API key used")
-        send_error_response(conn, 401, "API key has expired")
+  defp handle_rate_limit_check(conn, api_key, user, organisation) do
+    case ApiKeys.check_rate_limit(api_key) do
+      {:ok, _} ->
+        conn
+        |> assign(:current_user, user)
+        |> assign(:current_organisation, organisation)
+        |> assign(:api_key, api_key)
+        |> assign(:authenticated_via, :api_key)
+
+      {:error, :rate_limit_exceeded} ->
+        Logger.warning("API key rate limit exceeded: #{api_key.id}")
+        send_error_response(conn, 429, "Rate limit exceeded")
+    end
+  end
 
-      {:error, :api_key_inactive} ->
-        Logger.warning("Inactive API key used")
-        send_error_response(conn, 401, "API key is inactive")
+  defp handle_authentication_error(conn, :invalid_api_key) do
+    Logger.warning("Invalid API key provided")
+    send_error_response(conn, 401, "Invalid API key")
+  end
 
-      {:error, :ip_not_whitelisted} ->
-        Logger.warning("API key used from non-whitelisted IP")
-        send_error_response(conn, 403, "IP address not authorized for this API key")
+  defp handle_authentication_error(conn, :api_key_expired) do
+    Logger.warning("Expired API key used")
+    send_error_response(conn, 401, "API key has expired")
+  end
 
-      {:error, :user_not_found} ->
-        Logger.warning("API key user not found")
-        send_error_response(conn, 401, "User associated with API key not found")
+  defp handle_authentication_error(conn, :api_key_inactive) do
+    Logger.warning("Inactive API key used")
+    send_error_response(conn, 401, "API key is inactive")
+  end
 
-      {:error, reason} ->
-        Logger.warning("API key authentication failed: #{inspect(reason)}")
-        send_error_response(conn, 401, "API key authentication failed")
-    end
+  defp handle_authentication_error(conn, :ip_not_whitelisted) do
+    Logger.warning("API key used from non-whitelisted IP")
+    send_error_response(conn, 403, "IP address not authorized for this API key")
+  end
+
+  defp handle_authentication_error(conn, :user_not_found) do
+    Logger.warning("API key user not found")
+    send_error_response(conn, 401, "User associated with API key not found")
+  end
+
+  defp handle_authentication_error(conn, reason) do
+    Logger.warning("API key authentication failed: #{inspect(reason)}")
+    send_error_response(conn, 401, "API key authentication failed")
   end
 
   defp get_remote_ip(conn) do
@@ -119,4 +131,3 @@ defmodule WraftDocWeb.Plug.ApiKeyAuth do
     |> halt()
   end
 end
-

lib/wraft_doc_web/plugs/ensure_authenticated.ex

@@ -1,13 +1,13 @@
 defmodule WraftDocWeb.Plug.EnsureAuthenticated do
   @moduledoc """
   Ensures that a request is authenticated via either API Key or JWT.
-  
+
   This plug checks if current_user is set in conn.assigns.
   If not, it returns a 401 Unauthorized response.
-  
+
   This works with both API Key and JWT authentication methods.
   """
-  
+
   import Plug.Conn
 
   def init(opts), do: opts
@@ -29,4 +29,3 @@ defmodule WraftDocWeb.Plug.EnsureAuthenticated do
     |> halt()
   end
 end
-

lib/wraft_doc_web/views/api_key_view.ex

@@ -18,7 +18,7 @@ defmodule WraftDocWeb.Api.V1.ApiKeyView do
   end
 
   def render("api_key.json", %{api_key: api_key}) do
-    %{
+    base_map = %{
       id: api_key.id,
       name: api_key.name,
       key_prefix: api_key.key_prefix,
@@ -34,7 +34,8 @@ defmodule WraftDocWeb.Api.V1.ApiKeyView do
       user: render_user(api_key),
       created_by: render_created_by(api_key)
     }
-    |> maybe_add_key(api_key)
+
+    maybe_add_key(base_map, api_key)
   end
 
   def render("api_key_list.json", %{api_key: api_key}) do
@@ -85,4 +86,3 @@ defmodule WraftDocWeb.Api.V1.ApiKeyView do
     }
   end
 end
-

priv/repo/migrations/20251118100000_create_api_keys.exs

@@ -7,28 +7,28 @@ defmodule WraftDoc.Repo.Migrations.CreateApiKeys do
       add(:name, :string, null: false)
       add(:key_hash, :string, null: false)
       add(:key_prefix, :string, null: false)
-      
+
       add(:organisation_id, references(:organisation, type: :uuid, on_delete: :delete_all),
         null: false
       )
-      
+
       add(:user_id, references(:user, type: :uuid, on_delete: :delete_all), null: false)
-      
+
       add(:created_by_id, references(:user, type: :uuid, on_delete: :nilify_all))
-      
+
       # Security settings
       add(:expires_at, :utc_datetime)
       add(:is_active, :boolean, default: true, null: false)
       add(:rate_limit, :integer, default: 1000)
       add(:ip_whitelist, {:array, :string}, default: [])
-      
+
       # Usage tracking
       add(:last_used_at, :utc_datetime)
       add(:usage_count, :integer, default: 0, null: false)
-      
+
       # Additional metadata
       add(:metadata, :map, default: %{})
-      
+
       timestamps()
     end
 
@@ -41,4 +41,3 @@ defmodule WraftDoc.Repo.Migrations.CreateApiKeys do
     create(unique_index(:api_keys, [:name, :organisation_id]))
   end
 end
-

test/support/factory.ex

@@ -726,10 +726,13 @@ defmodule WraftDoc.Factory do
     user = build(:user)
 
     # Generate a sample API key
-    prefix = :crypto.strong_rand_bytes(4) |> Base.encode16(case: :lower)
-    random_part = :crypto.strong_rand_bytes(32) |> Base.url_encode64(padding: false) |> binary_part(0, 32)
+    prefix = Base.encode16(:crypto.strong_rand_bytes(4), case: :lower)
+
+    encoded = Base.url_encode64(:crypto.strong_rand_bytes(32), padding: false)
+    random_part = binary_part(encoded, 0, 32)
+
     full_key = "wraft_#{prefix}_#{random_part}"
-    
+
     %ApiKey{
       name: sequence(:api_key_name, &"API Key #{&1}"),
       key_hash: Bcrypt.hash_pwd_salt(full_key),

test/wraft_doc/api_keys/api_key_test.exs

@@ -35,7 +35,7 @@ defmodule WraftDoc.ApiKeys.ApiKeyTest do
       assert get_change(changeset, :key_hash) != nil
       assert get_change(changeset, :key_prefix) != nil
       assert get_change(changeset, :key) != nil
-      
+
       # Check key format
       key = get_change(changeset, :key)
       assert String.starts_with?(key, "wraft_")
@@ -240,4 +240,3 @@ defmodule WraftDoc.ApiKeys.ApiKeyTest do
     end
   end
 end
-