Add comprehensive API v1 with OAuth and API key authentication (#2389)

* OAuth

* Add API test routes and update Doorkeeper token handling for test environment

- Introduced API namespace with test routes for controller testing in the test environment.
- Updated Doorkeeper configuration to allow fallback to plain tokens in the test environment for easier testing.
- Modified schema to change resource_owner_id type from bigint to string.

* Implement API key authentication and enhance access control

- Replaced Doorkeeper OAuth authentication with a custom method supporting both OAuth and API keys in the BaseController.
- Added methods for API key authentication, including validation and logging.
- Introduced scope-based authorization for API keys in the TestController.
- Updated routes to include API key management endpoints.
- Enhanced logging for API access to include authentication method details.
- Added tests for API key functionality, including validation, scope checks, and access control enforcement.

* Add API key rate limiting and usage tracking

- Implemented rate limiting for API key authentication in BaseController.
- Added methods to check rate limits, render appropriate responses, and include rate limit headers in responses.
- Updated routes to include a new usage resource for tracking API usage.
- Enhanced tests to verify rate limit functionality, including exceeding limits and per-key tracking.
- Cleaned up Redis data in tests to ensure isolation between test cases.

* Add Jbuilder for JSON rendering and refactor AccountsController

- Added Jbuilder gem for improved JSON response handling.
- Refactored index action in AccountsController to utilize Jbuilder for rendering JSON.
- Removed manual serialization of accounts and streamlined response structure.
- Implemented a before_action in BaseController to enforce JSON format for all API requests.

* Add transactions resource to API routes

- Added routes for transactions, allowing index, show, create, update, and destroy actions.
- This enhancement supports comprehensive transaction management within the API.

* Enhance API authentication and onboarding handling

- Updated BaseController to skip onboarding requirements for API endpoints and added manual token verification for OAuth authentication.
- Improved error handling and logging for invalid access tokens.
- Introduced a method to set up the current context for API requests, ensuring compatibility with session-like behavior.
- Excluded API paths from onboarding redirects in the Onboardable concern.
- Updated database schema to change resource_owner_id type from bigint to string for OAuth access grants.

* Fix rubocop offenses

- Fix indentation and spacing issues
- Convert single quotes to double quotes
- Add spaces inside array brackets
- Fix comment alignment
- Add missing trailing newlines
- Correct else/end alignment

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Fix API test failures and improve test reliability

- Fix ApiRateLimiterTest by removing mock users method and using fixtures
- Fix UsageControllerTest by removing mock users method and using fixtures
- Fix BaseControllerTest by using different users for multiple API keys
- Use unique display_key values with SecureRandom to avoid conflicts
- Fix double render issue in UsageController by returning after authorize_scope\!
- Specify controller name in routes for usage resource
- Remove trailing whitespace and empty lines per Rubocop

All tests now pass and linting is clean.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Add API transactions controller warning to brakeman ignore

The account_id parameter in the API transactions controller is properly
validated on line 79: family.accounts.find(transaction_params[:account_id])
This ensures users can only create transactions in accounts belonging to
their family, making this a false positive.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Signed-off-by: Josh Pigford <josh@joshpigford.com>
Co-authored-by: Claude <noreply@anthropic.com>

app/controllers/api/v1/accounts_controller.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+class Api::V1::AccountsController < Api::V1::BaseController
+  include Pagy::Backend
+
+  # Ensure proper scope authorization for read access
+  before_action :ensure_read_scope
+
+  def index
+    # Test with Pagy pagination
+    family = current_resource_owner.family
+    accounts_query = family.accounts.active.alphabetically
+
+    # Handle pagination with Pagy
+    @pagy, @accounts = pagy(
+      accounts_query,
+      page: safe_page_param,
+      limit: safe_per_page_param
+    )
+
+    @per_page = safe_per_page_param
+
+    # Rails will automatically use app/views/api/v1/accounts/index.json.jbuilder
+    render :index
+  rescue => e
+    Rails.logger.error "AccountsController error: #{e.message}"
+    Rails.logger.error e.backtrace.join("\n")
+
+    render json: {
+      error: "internal_server_error",
+      message: "Error: #{e.message}"
+    }, status: :internal_server_error
+end
+
+    private
+
+      def ensure_read_scope
+        authorize_scope!(:read)
+      end
+
+
+
+      def safe_page_param
+        page = params[:page].to_i
+        page > 0 ? page : 1
+      end
+
+      def safe_per_page_param
+        per_page = params[:per_page].to_i
+
+        # Default to 25, max 100
+        case per_page
+        when 1..100
+          per_page
+        else
+          25
+        end
+      end
+end

app/controllers/api/v1/base_controller.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+class Api::V1::BaseController < ApplicationController
+  include Doorkeeper::Rails::Helpers
+
+  # Skip regular session-based authentication for API
+  skip_authentication
+
+  # Skip onboarding requirements for API endpoints
+  skip_before_action :require_onboarding_and_upgrade
+
+  # Force JSON format for all API requests
+  before_action :force_json_format
+  # Use our custom authentication that supports both OAuth and API keys
+  before_action :authenticate_request!
+  before_action :check_api_key_rate_limit
+  before_action :log_api_access
+
+
+
+  # Override Doorkeeper's default behavior to return JSON instead of redirecting
+  def doorkeeper_unauthorized_render_options(error: nil)
+    { json: { error: "unauthorized", message: "Access token is invalid, expired, or missing" } }
+  end
+
+  # Error handling for common API errors
+  rescue_from ActiveRecord::RecordNotFound, with: :handle_not_found
+  rescue_from Doorkeeper::Errors::DoorkeeperError, with: :handle_unauthorized
+  rescue_from ActionController::ParameterMissing, with: :handle_bad_request
+
+  private
+
+    # Force JSON format for all API requests
+    def force_json_format
+      request.format = :json
+    end
+
+    # Authenticate using either OAuth or API key
+    def authenticate_request!
+      return if authenticate_oauth
+      return if authenticate_api_key
+      render_unauthorized unless performed?
+    end
+
+    # Try OAuth authentication first
+    def authenticate_oauth
+      return false unless request.headers["Authorization"].present?
+
+      # Manually verify the token (bypassing doorkeeper_authorize! which had scope issues)
+      token_string = request.authorization&.split(" ")&.last
+      access_token = Doorkeeper::AccessToken.by_token(token_string)
+
+      # Check token validity and scope (read_write includes read access)
+      has_sufficient_scope = access_token&.scopes&.include?("read") || access_token&.scopes&.include?("read_write")
+
+      unless access_token && !access_token.expired? && has_sufficient_scope
+        render_json({ error: "unauthorized", message: "Access token is invalid, expired, or missing required scope" }, status: :unauthorized)
+        return false
+      end
+
+      # Set the doorkeeper_token for compatibility
+      @_doorkeeper_token = access_token
+
+      if doorkeeper_token&.resource_owner_id
+        @current_user = User.find_by(id: doorkeeper_token.resource_owner_id)
+
+        # If user doesn't exist, the token is invalid (user was deleted)
+        unless @current_user
+          Rails.logger.warn "API OAuth Token Invalid: Access token resource_owner_id #{doorkeeper_token.resource_owner_id} does not exist"
+          render_json({ error: "unauthorized", message: "Access token is invalid - user not found" }, status: :unauthorized)
+          return false
+        end
+      else
+        Rails.logger.warn "API OAuth Token Invalid: Access token missing resource_owner_id"
+        render_json({ error: "unauthorized", message: "Access token is invalid - missing resource owner" }, status: :unauthorized)
+        return false
+      end
+
+      @authentication_method = :oauth
+      setup_current_context_for_api
+      true
+    rescue Doorkeeper::Errors::DoorkeeperError => e
+      Rails.logger.warn "API OAuth Error: #{e.message}"
+      false
+    end
+
+    # Try API key authentication
+    def authenticate_api_key
+      api_key_value = request.headers["X-Api-Key"]
+      return false unless api_key_value
+
+      @api_key = ApiKey.find_by_value(api_key_value)
+      return false unless @api_key && @api_key.active?
+
+      @current_user = @api_key.user
+      @api_key.update_last_used!
+      @authentication_method = :api_key
+      @rate_limiter = ApiRateLimiter.new(@api_key)
+      setup_current_context_for_api
+      true
+    end
+
+    # Check rate limits for API key authentication
+    def check_api_key_rate_limit
+      return unless @authentication_method == :api_key && @rate_limiter
+
+      if @rate_limiter.rate_limit_exceeded?
+        usage_info = @rate_limiter.usage_info
+        render_rate_limit_exceeded(usage_info)
+        return false
+      end
+
+      # Increment request count for successful API key requests
+      @rate_limiter.increment_request_count!
+
+      # Add rate limit headers to response
+      add_rate_limit_headers(@rate_limiter.usage_info)
+    end
+
+    # Render rate limit exceeded response
+    def render_rate_limit_exceeded(usage_info)
+      response.headers["X-RateLimit-Limit"] = usage_info[:rate_limit].to_s
+      response.headers["X-RateLimit-Remaining"] = "0"
+      response.headers["X-RateLimit-Reset"] = usage_info[:reset_time].to_s
+      response.headers["Retry-After"] = usage_info[:reset_time].to_s
+
+      Rails.logger.warn "API Rate Limit Exceeded: API Key #{@api_key.name} (User: #{@current_user.email}) - #{usage_info[:current_count]}/#{usage_info[:rate_limit]} requests"
+
+      render_json({
+        error: "rate_limit_exceeded",
+        message: "Rate limit exceeded. Try again in #{usage_info[:reset_time]} seconds.",
+        details: {
+          limit: usage_info[:rate_limit],
+          current: usage_info[:current_count],
+          reset_in_seconds: usage_info[:reset_time]
+        }
+      }, status: :too_many_requests)
+    end
+
+    # Add rate limit headers to successful responses
+    def add_rate_limit_headers(usage_info)
+      response.headers["X-RateLimit-Limit"] = usage_info[:rate_limit].to_s
+      response.headers["X-RateLimit-Remaining"] = usage_info[:remaining].to_s
+      response.headers["X-RateLimit-Reset"] = usage_info[:reset_time].to_s
+    end
+
+    # Render unauthorized response
+    def render_unauthorized
+      render_json({ error: "unauthorized", message: "Access token or API key is invalid, expired, or missing" }, status: :unauthorized)
+    end
+
+    # Returns the user that owns the access token or API key
+    def current_resource_owner
+      @current_user
+    end
+
+    # Get current scopes from either authentication method
+    def current_scopes
+      case @authentication_method
+      when :oauth
+        doorkeeper_token&.scopes&.to_a || []
+      when :api_key
+        @api_key&.scopes || []
+      else
+        []
+      end
+    end
+
+    # Check if the current authentication has the required scope
+    # Implements hierarchical scope checking where read_write includes read access
+    def authorize_scope!(required_scope)
+      scopes = current_scopes
+
+      case required_scope.to_s
+      when "read"
+        # Read access requires either "read" or "read_write" scope
+        has_access = scopes.include?("read") || scopes.include?("read_write")
+      when "write"
+        # Write access requires "read_write" scope
+        has_access = scopes.include?("read_write")
+      else
+        # For any other scope, check exact match (backward compatibility)
+        has_access = scopes.include?(required_scope.to_s)
+      end
+
+      unless has_access
+        Rails.logger.warn "API Insufficient Scope: User #{current_resource_owner&.email} attempted to access #{required_scope} but only has #{scopes}"
+        render_json({ error: "insufficient_scope", message: "This action requires the '#{required_scope}' scope" }, status: :forbidden)
+        return false
+      end
+      true
+    end
+
+    # Consistent JSON response method
+    def render_json(data, status: :ok)
+      render json: data, status: status
+    end
+
+    # Error handlers
+    def handle_not_found(exception)
+      Rails.logger.warn "API Record Not Found: #{exception.message}"
+      render_json({ error: "record_not_found", message: "The requested resource was not found" }, status: :not_found)
+    end
+
+    def handle_unauthorized(exception)
+      Rails.logger.warn "API Unauthorized: #{exception.message}"
+      render_json({ error: "unauthorized", message: "Access token is invalid or expired" }, status: :unauthorized)
+    end
+
+    def handle_bad_request(exception)
+      Rails.logger.warn "API Bad Request: #{exception.message}"
+      render_json({ error: "bad_request", message: "Required parameters are missing or invalid" }, status: :bad_request)
+    end
+
+    # Log API access for monitoring and debugging
+    def log_api_access
+      return unless current_resource_owner
+
+      auth_info = case @authentication_method
+      when :oauth
+        "OAuth Token"
+      when :api_key
+        "API Key: #{@api_key.name}"
+      else
+        "Unknown"
+      end
+
+      Rails.logger.info "API Request: #{request.method} #{request.path} - User: #{current_resource_owner.email} (Family: #{current_resource_owner.family_id}) - Auth: #{auth_info}"
+    end
+
+    # Family-based access control helper (to be used by subcontrollers)
+    def ensure_current_family_access(resource)
+      return unless resource.respond_to?(:family_id)
+
+      unless resource.family_id == current_resource_owner.family_id
+        Rails.logger.warn "API Forbidden: User #{current_resource_owner.email} attempted to access resource from family #{resource.family_id}"
+        render_json({ error: "forbidden", message: "Access denied to this resource" }, status: :forbidden)
+        return false
+      end
+
+      true
+    end
+
+    # Manual doorkeeper_token accessor for compatibility with manual token verification
+    def doorkeeper_token
+      @_doorkeeper_token
+    end
+
+    # Set up Current context for API requests since we don't use session-based auth
+    def setup_current_context_for_api
+      # For API requests, we need to create a minimal session-like object
+      # or find/create an actual session for this user to make Current.user work
+      if @current_user
+        # Try to find an existing session for this user, or create a temporary one
+        session = @current_user.sessions.first
+        if session
+          Current.session = session
+        else
+          # Create a temporary session for this API request
+          # This won't be persisted but will allow Current.user to work
+          session = @current_user.sessions.build(
+            user_agent: request.user_agent,
+            ip_address: request.ip
+          )
+          Current.session = session
+        end
+      end
+    end
+end

app/controllers/api/v1/test_controller.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Test controller for API V1 Base Controller functionality
+# This controller is only used for testing the base controller behavior
+class Api::V1::TestController < Api::V1::BaseController
+  def index
+    render_json({ message: "test_success", user: current_resource_owner&.email })
+  end
+
+  def not_found
+    # Trigger RecordNotFound error for testing error handling
+    raise ActiveRecord::RecordNotFound, "Test record not found"
+  end
+
+  def family_access
+    # Test family-based access control
+    # Create a mock resource that belongs to a different family
+    mock_resource = OpenStruct.new(family_id: 999)  # Different family ID
+
+    # Check family access - if it returns false, it already rendered the error
+    if ensure_current_family_access(mock_resource)
+      # If we get here, access was allowed
+      render_json({ family_id: current_resource_owner.family_id })
+    end
+  end
+
+  def scope_required
+    # Test scope authorization - require write scope
+    return unless authorize_scope!("write")
+
+    render_json({
+      message: "scope_authorized",
+      scopes: current_scopes,
+      required_scope: "write"
+    })
+  end
+
+  def multiple_scopes_required
+    # Test read scope requirement
+    return unless authorize_scope!("read")
+
+    render_json({
+      message: "read_scope_authorized",
+      scopes: current_scopes
+    })
+  end
+end

app/controllers/api/v1/transactions_controller.rb

@@ -0,0 +1,327 @@
+# frozen_string_literal: true
+
+class Api::V1::TransactionsController < Api::V1::BaseController
+  include Pagy::Backend
+
+  # Ensure proper scope authorization for read vs write access
+  before_action :ensure_read_scope, only: [ :index, :show ]
+  before_action :ensure_write_scope, only: [ :create, :update, :destroy ]
+  before_action :set_transaction, only: [ :show, :update, :destroy ]
+
+  def index
+    family = current_resource_owner.family
+    transactions_query = family.transactions.active
+
+    # Apply filters
+    transactions_query = apply_filters(transactions_query)
+
+    # Apply search
+    transactions_query = apply_search(transactions_query) if params[:search].present?
+
+    # Include necessary associations for efficient queries
+    transactions_query = transactions_query.includes(
+      { entry: :account },
+      :category, :merchant, :tags,
+      transfer_as_outflow: { inflow_transaction: { entry: :account } },
+      transfer_as_inflow: { outflow_transaction: { entry: :account } }
+    ).reverse_chronological
+
+    # Handle pagination with Pagy
+    @pagy, @transactions = pagy(
+      transactions_query,
+      page: safe_page_param,
+      limit: safe_per_page_param
+    )
+
+    # Make per_page available to the template
+    @per_page = safe_per_page_param
+
+    # Rails will automatically use app/views/api/v1/transactions/index.json.jbuilder
+    render :index
+
+  rescue => e
+    Rails.logger.error "TransactionsController#index error: #{e.message}"
+    Rails.logger.error e.backtrace.join("\n")
+
+    render json: {
+      error: "internal_server_error",
+      message: "Error: #{e.message}"
+    }, status: :internal_server_error
+  end
+
+  def show
+    # Rails will automatically use app/views/api/v1/transactions/show.json.jbuilder
+    render :show
+
+  rescue => e
+    Rails.logger.error "TransactionsController#show error: #{e.message}"
+    Rails.logger.error e.backtrace.join("\n")
+
+    render json: {
+      error: "internal_server_error",
+      message: "Error: #{e.message}"
+    }, status: :internal_server_error
+  end
+
+  def create
+    family = current_resource_owner.family
+
+    # Validate account_id is present
+    unless transaction_params[:account_id].present?
+      render json: {
+        error: "validation_failed",
+        message: "Account ID is required",
+        errors: [ "Account ID is required" ]
+      }, status: :unprocessable_entity
+      return
+    end
+
+    account = family.accounts.find(transaction_params[:account_id])
+    @entry = account.entries.new(entry_params_for_create)
+
+    if @entry.save
+      @entry.sync_account_later
+      @entry.lock_saved_attributes!
+      @entry.transaction.lock_attr!(:tag_ids) if @entry.transaction.tags.any?
+
+      @transaction = @entry.transaction
+      render :show, status: :created
+    else
+      render json: {
+        error: "validation_failed",
+        message: "Transaction could not be created",
+        errors: @entry.errors.full_messages
+      }, status: :unprocessable_entity
+    end
+
+  rescue => e
+    Rails.logger.error "TransactionsController#create error: #{e.message}"
+    Rails.logger.error e.backtrace.join("\n")
+
+    render json: {
+      error: "internal_server_error",
+      message: "Error: #{e.message}"
+    }, status: :internal_server_error
+end
+
+  def update
+    if @entry.update(entry_params_for_update)
+      @entry.sync_account_later
+      @entry.lock_saved_attributes!
+      @entry.transaction.lock_attr!(:tag_ids) if @entry.transaction.tags.any?
+
+      @transaction = @entry.transaction
+      render :show
+    else
+      render json: {
+        error: "validation_failed",
+        message: "Transaction could not be updated",
+        errors: @entry.errors.full_messages
+      }, status: :unprocessable_entity
+    end
+
+  rescue => e
+    Rails.logger.error "TransactionsController#update error: #{e.message}"
+    Rails.logger.error e.backtrace.join("\n")
+
+    render json: {
+      error: "internal_server_error",
+      message: "Error: #{e.message}"
+    }, status: :internal_server_error
+  end
+
+  def destroy
+    @entry.destroy!
+    @entry.sync_account_later
+
+    render json: {
+      message: "Transaction deleted successfully"
+    }, status: :ok
+
+  rescue => e
+    Rails.logger.error "TransactionsController#destroy error: #{e.message}"
+    Rails.logger.error e.backtrace.join("\n")
+
+    render json: {
+      error: "internal_server_error",
+      message: "Error: #{e.message}"
+    }, status: :internal_server_error
+  end
+
+  private
+
+    def set_transaction
+      family = current_resource_owner.family
+      @transaction = family.transactions.find(params[:id])
+      @entry = @transaction.entry
+    rescue ActiveRecord::RecordNotFound
+      render json: {
+        error: "not_found",
+        message: "Transaction not found"
+      }, status: :not_found
+    end
+
+    def ensure_read_scope
+      authorize_scope!(:read)
+    end
+
+    def ensure_write_scope
+      authorize_scope!(:write)
+    end
+
+    def apply_filters(query)
+      # Account filtering
+      if params[:account_id].present?
+        query = query.joins(:entry).where(entries: { account_id: params[:account_id] })
+      end
+
+      if params[:account_ids].present?
+        account_ids = Array(params[:account_ids])
+        query = query.joins(:entry).where(entries: { account_id: account_ids })
+      end
+
+      # Category filtering
+      if params[:category_id].present?
+        query = query.where(category_id: params[:category_id])
+      end
+
+      if params[:category_ids].present?
+        category_ids = Array(params[:category_ids])
+        query = query.where(category_id: category_ids)
+      end
+
+      # Merchant filtering
+      if params[:merchant_id].present?
+        query = query.where(merchant_id: params[:merchant_id])
+      end
+
+      if params[:merchant_ids].present?
+        merchant_ids = Array(params[:merchant_ids])
+        query = query.where(merchant_id: merchant_ids)
+      end
+
+      # Date range filtering
+      if params[:start_date].present?
+        query = query.joins(:entry).where("entries.date >= ?", Date.parse(params[:start_date]))
+      end
+
+      if params[:end_date].present?
+        query = query.joins(:entry).where("entries.date <= ?", Date.parse(params[:end_date]))
+      end
+
+      # Amount filtering
+      if params[:min_amount].present?
+        min_amount = params[:min_amount].to_f
+        query = query.joins(:entry).where("entries.amount >= ?", min_amount)
+      end
+
+      if params[:max_amount].present?
+        max_amount = params[:max_amount].to_f
+        query = query.joins(:entry).where("entries.amount <= ?", max_amount)
+      end
+
+      # Tag filtering
+      if params[:tag_ids].present?
+        tag_ids = Array(params[:tag_ids])
+        query = query.joins(:tags).where(tags: { id: tag_ids })
+      end
+
+      # Transaction type filtering (income/expense)
+      if params[:type].present?
+        case params[:type].downcase
+        when "income"
+          query = query.joins(:entry).where("entries.amount < 0")
+        when "expense"
+          query = query.joins(:entry).where("entries.amount > 0")
+        end
+      end
+
+      query
+    end
+
+    def apply_search(query)
+      search_term = "%#{params[:search]}%"
+
+      query.joins(:entry)
+           .left_joins(:merchant)
+           .where(
+             "entries.name ILIKE ? OR entries.notes ILIKE ? OR merchants.name ILIKE ?",
+             search_term, search_term, search_term
+           )
+end
+
+    def transaction_params
+      params.require(:transaction).permit(
+        :account_id, :date, :amount, :name, :description, :notes, :currency,
+        :category_id, :merchant_id, :nature, tag_ids: []
+      )
+    end
+
+    def entry_params_for_create
+      entry_params = {
+        name: transaction_params[:name] || transaction_params[:description],
+        date: transaction_params[:date],
+        amount: calculate_signed_amount,
+        currency: transaction_params[:currency] || current_resource_owner.family.currency,
+        notes: transaction_params[:notes],
+        entryable_type: "Transaction",
+        entryable_attributes: {
+          category_id: transaction_params[:category_id],
+          merchant_id: transaction_params[:merchant_id],
+          tag_ids: transaction_params[:tag_ids] || []
+        }
+      }
+
+      entry_params.compact
+    end
+
+    def entry_params_for_update
+      entry_params = {
+        name: transaction_params[:name] || transaction_params[:description],
+        date: transaction_params[:date],
+        notes: transaction_params[:notes],
+        entryable_attributes: {
+          id: @entry.entryable_id,
+          category_id: transaction_params[:category_id],
+          merchant_id: transaction_params[:merchant_id],
+          tag_ids: transaction_params[:tag_ids]
+        }.compact_blank
+      }
+
+      # Only update amount if provided
+      if transaction_params[:amount].present?
+        entry_params[:amount] = calculate_signed_amount
+      end
+
+      entry_params.compact
+    end
+
+    def calculate_signed_amount
+      amount = transaction_params[:amount].to_f
+      nature = transaction_params[:nature]
+
+      case nature&.downcase
+      when "income", "inflow"
+        -amount.abs  # Income is negative
+      when "expense", "outflow"
+        amount.abs   # Expense is positive
+      else
+        amount       # Use as provided
+      end
+    end
+
+    def safe_page_param
+      page = params[:page].to_i
+      page > 0 ? page : 1
+    end
+
+    def safe_per_page_param
+      per_page = params[:per_page].to_i
+      case per_page
+      when 1..100
+        per_page
+      else
+        25  # Default
+      end
+    end
+end

app/controllers/api/v1/usage_controller.rb

@@ -0,0 +1,38 @@
+class Api::V1::UsageController < Api::V1::BaseController
+  # GET /api/v1/usage
+  def show
+    return unless authorize_scope!(:read)
+
+    case @authentication_method
+    when :api_key
+      usage_info = @rate_limiter.usage_info
+      render_json({
+        api_key: {
+          name: @api_key.name,
+          scopes: @api_key.scopes,
+          last_used_at: @api_key.last_used_at,
+          created_at: @api_key.created_at
+        },
+        rate_limit: {
+          tier: usage_info[:tier],
+          limit: usage_info[:rate_limit],
+          current_count: usage_info[:current_count],
+          remaining: usage_info[:remaining],
+          reset_in_seconds: usage_info[:reset_time],
+          reset_at: Time.current + usage_info[:reset_time].seconds
+        }
+      })
+    when :oauth
+      # For OAuth, we don't track detailed usage yet, but we can return basic info
+      render_json({
+        authentication_method: "oauth",
+        message: "Detailed usage tracking is available for API key authentication"
+      })
+    else
+      render_json({
+        error: "invalid_authentication_method",
+        message: "Unable to determine usage information"
+      }, status: :bad_request)
+    end
+  end
+end