haveapi 0.28.3 → 0.29.0

data/lib/haveapi/extensions/exception_mailer.rb

@@ -11,6 +11,21 @@ module HaveAPI::Extensions
   # is added. Some helper methods are taken either from Sinatra or Rack.
   class ExceptionMailer < Base
     Frame = Struct.new(:filename, :lineno, :function, :context_line)
+    FILTERED_VALUE = '[FILTERED]'.freeze
+    SENSITIVE_KEY_PATTERN = /
+      authorization|cookie|password|passwd|passphrase|secret|token|
+      api[_-]?key|credential|jwt|session|csrf|query_string|form_vars|
+      request_uri|original_fullpath|fullpath
+    /ix
+    SENSITIVE_STRING_PATTERN = /
+      (
+        (?:authorization|cookie|password|passwd|passphrase|secret|token|
+           api[_-]?key|credential|jwt|session|csrf)
+        [^=:\s&;<>]{0,64}
+        \s*(?:=|:|=>)\s*["']?
+      )
+      [^&;\s<"'}]+
+    /ix
 
     # @param opts [Hash] options
     # @option opts to [String] recipient address
@@ -24,21 +39,33 @@ module HaveAPI::Extensions
 
     def enabled(server)
       HaveAPI::Action.connect_hook(:exec_exception) do |ret, context, e|
-        log(context, e)
+        safe_log(context, e)
         ret
       end
 
       server.connect_hook(:description_exception) do |ret, context, e|
-        log(context, e)
+        safe_log(context, e)
         ret
       end
+
+      server.connect_hook(:request_exception) do |ret, context, e|
+        safe_log(context, e)
+        ret
+      end
+    end
+
+    def safe_log(context, exception)
+      log(context, exception)
+    rescue StandardError => e
+      warn "HaveAPI::Extensions::ExceptionMailer failed: #{e.class}: #{e.message}"
     end
 
     def log(context, exception)
-      req = context.request.request
-      path = (req.script_name + req.path_info).squeeze('/')
+      request_context = context&.request
+      req = request_context.respond_to?(:request) ? request_context.request : request_context
+      path = request_path(context, req)
 
-      frames = exception.backtrace.map do |line|
+      frames = Array(exception.backtrace).map do |line|
         frame = Frame.new
 
         next unless line =~ /(.*?):(\d+)(:in `(.*)')?/
@@ -57,14 +84,21 @@ module HaveAPI::Extensions
 
         frame
       end.compact
+      frames = [Frame.new('(unknown)', 0, nil, nil)] if frames.empty?
 
-      env = context.request.env
+      args = redact(context&.args)
+      path_params = redact(context&.path_params)
+      input = redact(context&.input)
+      get = request_params(req, :GET)
+      post = request_params(req, :POST)
+      cookies = request_cookies(req)
+      env = redact(request_env(request_context, req))
 
       user =
-        if context.current_user.respond_to?(:id)
+        if context&.current_user.respond_to?(:id)
           context.current_user.id
         else
-          context.current_user
+          context&.current_user
         end
 
       mail(context, exception, TEMPLATE.result(binding))
@@ -114,6 +148,91 @@ module HaveAPI::Extensions
       end
     end
 
+    def request_path(context, req)
+      if req.respond_to?(:script_name) && req.respond_to?(:path_info)
+        return filter_query_string((req.script_name + req.path_info).squeeze('/'))
+      end
+
+      filter_query_string(
+        if context.respond_to?(:resolved_path)
+          context.resolved_path
+        elsif context.respond_to?(:path)
+          context.path
+        else
+          '(unknown)'
+        end
+      )
+    end
+
+    def request_env(request_context, req)
+      if request_context.respond_to?(:env)
+        request_context.env
+      elsif req.respond_to?(:env)
+        req.env
+      else
+        {}
+      end
+    end
+
+    def request_params(req, method)
+      return {} unless req.respond_to?(method)
+
+      redact(req.public_send(method) || {})
+    rescue StandardError
+      {}
+    end
+
+    def request_cookies(req)
+      return {} unless req.respond_to?(:cookies)
+
+      cookies = req.cookies || {}
+
+      cookies.each_with_object({}) do |(key, _value), ret|
+        ret[key] = FILTERED_VALUE
+      end
+    rescue StandardError
+      {}
+    end
+
+    def filter_query_string(path)
+      return path unless path.respond_to?(:sub)
+
+      path.sub(/\?.*/, "?#{FILTERED_VALUE}")
+    end
+
+    def redact(value, key = nil, seen = nil)
+      return FILTERED_VALUE if sensitive_key?(key)
+
+      seen ||= {}.compare_by_identity
+
+      case value
+      when Hash
+        return value if seen.has_key?(value)
+
+        seen[value] = true
+        value.each_with_object({}) do |(inner_key, inner_value), ret|
+          ret[inner_key] = redact(inner_value, inner_key, seen)
+        end
+      when Array
+        return value if seen.has_key?(value)
+
+        seen[value] = true
+        value.map { |inner_value| redact(inner_value, nil, seen) }
+      when String
+        redact_string(value)
+      else
+        value
+      end
+    end
+
+    def sensitive_key?(key)
+      key && key.to_s.match?(SENSITIVE_KEY_PATTERN)
+    end
+
+    def redact_string(value)
+      value.gsub(SENSITIVE_STRING_PATTERN, "\\1#{FILTERED_VALUE}")
+    end
+
     TEMPLATE = ERB.new(<<~END
       <!DOCTYPE html>
       <html>
@@ -224,15 +343,15 @@ module HaveAPI::Extensions
                 </tr>
                 <tr>
                   <th>Arguments</th>
-                  <td><%=h context.args %></td>
+                  <td><%=h args %></td>
                 </tr>
                 <tr>
                   <th>Path parameters</th>
-                  <td><%=h context.path_params %></td>
+                  <td><%=h path_params %></td>
                 </tr>
                 <tr>
                   <th>Input</th>
-                  <td><%=h context.input %></td>
+                  <td><%=h input %></td>
                 </tr>
                 <tr>
                   <th>User</th>
@@ -269,13 +388,13 @@ module HaveAPI::Extensions
             </div> <!-- /BACKTRACE -->
             <div id="get">
               <h3 id="get-info">GET</h3>
-              <% if req.GET and not req.GET.empty? %>
+              <% if !get.empty? %>
                 <table class="req">
                   <tr>
                     <th>Variable</th>
                     <th>Value</th>
                   </tr>
-                  <% req.GET.sort_by { |k, v| k.to_s }.each { |key, val| %>
+                  <% get.sort_by { |k, v| k.to_s }.each { |key, val| %>
                   <tr>
                     <td><%=h key %></td>
                     <td class="code"><div><%=h val.inspect %></div></td>
@@ -289,13 +408,13 @@ module HaveAPI::Extensions
             </div> <!-- /GET -->
             <div id="post">
               <h3 id="post-info">POST</h3>
-              <% if req.POST and not req.POST.empty? %>
+              <% if !post.empty? %>
                 <table class="req">
                   <tr>
                     <th>Variable</th>
                     <th>Value</th>
                   </tr>
-                  <% req.POST.sort_by { |k, v| k.to_s }.each { |key, val| %>
+                  <% post.sort_by { |k, v| k.to_s }.each { |key, val| %>
                   <tr>
                     <td><%=h key %></td>
                     <td class="code"><div><%=h val.inspect %></div></td>
@@ -309,13 +428,13 @@ module HaveAPI::Extensions
             </div> <!-- /POST -->
             <div id="cookies">
               <h3 id="cookie-info">COOKIES</h3>
-              <% unless req.cookies.empty? %>
+              <% unless cookies.empty? %>
                 <table class="req">
                   <tr>
                     <th>Variable</th>
                     <th>Value</th>
                   </tr>
-                  <% req.cookies.each { |key, val| %>
+                  <% cookies.each { |key, val| %>
                     <tr>
                       <td><%=h key %></td>
                       <td class="code"><div><%=h val.inspect %></div></td>

data/lib/haveapi/i18n.rb

@@ -0,0 +1,125 @@
+require 'i18n'
+
+module HaveAPI
+  class LocalizedMessage
+    attr_reader :key, :values, :default
+
+    def initialize(key, default: nil, scope: nil, **values)
+      @key = normalize_key(key, scope)
+      @default = default
+      @values = values
+    end
+
+    def translate(extra_values = {})
+      values = localized_values(@values.merge(extra_values))
+      opts = values
+      opts[:default] = @default if @default
+
+      ::I18n.t(@key, **opts)
+    end
+
+    def to_s
+      translate
+    end
+
+    private
+
+    def normalize_key(key, scope)
+      return key.to_s unless scope
+
+      "#{scope}.#{key}"
+    end
+
+    def localized_values(values)
+      values.transform_values do |value|
+        case value
+        when Array
+          value.map { |v| HaveAPI.localize(v) }.join('; ')
+        else
+          HaveAPI.localize(value)
+        end
+      end
+    end
+  end
+
+  module I18n
+    class << self
+      def setup
+        locale_dir = File.expand_path('locales', __dir__)
+        ::I18n.load_path |= Dir[File.join(locale_dir, '*.yml')]
+      end
+
+      def available_locales
+        locale_dir = File.expand_path('locales', __dir__)
+
+        Dir[File.join(locale_dir, '*.yml')].map do |path|
+          File.basename(path, '.yml').to_sym
+        end.sort
+      end
+
+      def accept_language(header, available_locales)
+        header.to_s.split(',').each_with_index.filter_map do |raw, index|
+          tag, *params = raw.strip.split(';')
+          next if tag.nil? || tag.empty?
+
+          q = params.map(&:strip).grep(/\Aq=/).first
+          weight = q ? q.split('=', 2).last.to_f : 1.0
+          next if weight <= 0.0
+
+          [tag, weight, index]
+        end.sort_by { |(_, weight, index)| [-weight, index] }.each do |tag, _, _|
+          locale = normalize_locale(tag, available_locales)
+          return locale if locale
+        end
+
+        nil
+      rescue StandardError
+        nil
+      end
+
+      def normalize_locale(locale, available_locales)
+        return if locale.nil?
+
+        tag = locale.to_s.strip.tr('_', '-')
+        return if tag.empty? || tag == '*'
+
+        available = Array(available_locales).map(&:to_s)
+        candidates = [tag, tag.split('-').first].compact.map(&:downcase).uniq
+
+        candidates.each do |candidate|
+          match = available.detect { |v| v.downcase == candidate }
+          return match.to_sym if match
+        end
+
+        nil
+      end
+    end
+  end
+
+  class << self
+    def message(key, default: nil, scope: nil, **values)
+      LocalizedMessage.new(key, default:, scope:, **values)
+    end
+
+    def t(key, default: nil, scope: nil, **values)
+      message(key, default:, scope:, **values).translate
+    end
+
+    def localize(value, **extra_values)
+      case value
+      when LocalizedMessage
+        value.translate(extra_values)
+      when Array
+        value.map { |v| localize(v, **extra_values) }
+      when Hash
+        value.transform_values { |v| localize(v, **extra_values) }
+      when String
+        extra_values.empty? ? value : format(value, extra_values)
+      else
+        value
+      end
+    end
+  end
+end
+
+HaveAPI::I18n.setup

data/lib/haveapi/locales/cs.yml

@@ -0,0 +1,167 @@
+# This file is generated from i18n/haveapi.yml.
+# Do not edit it manually; manual changes will be overwritten.
+# Update i18n/haveapi.yml and run bundle exec rake i18n:update.
+---
+cs:
+  haveapi:
+    action_state:
+      cancellation_failed: zrušení selhalo
+      not_found: stav akce nebyl nalezen
+      timeout_max: timeout může být nejvýše %{max}
+    authentication:
+      failed: přihlášení selhalo
+      invalid_credentials: neplatné přihlašovací údaje
+      multiple_oauth2_tokens: Bylo poskytnuto více OAuth2 tokenů
+      multiple_tokens: Bylo poskytnuto více ověřovacích tokenů
+      renew_failed: obnovení selhalo
+      required: Akce vyžaduje přihlášení uživatele
+      revoke_failed: zrušení selhalo
+      token_required: Akce vyžaduje přihlášení uživatele tokenem
+    authorization:
+      insufficient_permissions: Přístup odepřen. Nedostatečná oprávnění.
+    errors:
+      action_not_found: Akce nebyla nalezena
+      bad_accept_header: Chybná hlavička Accept
+      bad_json_syntax: Chybná syntaxe JSON
+      json_body_object: Tělo JSON musí být objekt
+      server_error: Došlo k chybě serveru
+      unsupported_content_type: Nepodporovaný Content-Type
+    pagination:
+      limit_max: limit může být nejvýše %{max}
+    parameters:
+      action_state:
+        can_cancel:
+          description: Je-li true, spuštění této akce lze zrušit
+          label: Lze zrušit
+        created_at:
+          label: Vytvořeno
+        current:
+          label: Aktuální průběh
+        finished:
+          label: Dokončeno
+        label:
+          label: Popisek
+        poll:
+          current:
+            description: průběh, se kterým se porovnává při nastaveném update_in
+          status:
+            description: stav, se kterým se porovnává při nastaveném update_in
+          timeout:
+            description: v sekundách
+            label: Časový limit
+          total:
+            description: průběh, se kterým se porovnává při nastaveném update_in
+          update_in:
+            description: počet sekund, po kterém se stav vrátí, pokud se průběh změnil
+            label: Průběh
+        status:
+          description: Určuje, zda akce probíhá nebo selhává
+          label: Stav
+        total:
+          description: Akce je dokončena, když se aktuální průběh rovná celkovému
+          label: Celkem
+        unit:
+          description: Jednotka aktuálního a celkového průběhu
+          label: Jednotka
+        updated_at:
+          description: Kdy byl průběh naposledy aktualizován
+          label: Aktualizováno
+      action_state_id:
+        description: ID objektu ActionState pro dotazování stavu. Pokud je null, akce
+          není pro aktuální volání blokující.
+        label: ID stavu akce
+      active_record:
+        includes:
+          description: |-
+            Seznam názvů asociovaných prostředků oddělených čárkou.
+            Vnořené asociace se zapisují pomocí '__' mezi názvy prostředků.
+            Například 'user,node' přeloží tyto dvě asociace.
+            Pro přeložení dalších asociací uzlu použijte např. 'user,node__location',
+            pro ještě hlubší úroveň např. 'user,node__location__environment'.
+          label: Zahrnuté asociace
+        path_params:
+          description: Pole parametrů potřebných k přeložení URL na tento objekt
+          label: Parametry URL
+        resolved:
+          description: True, pokud je asociace přeložena
+          label: Přeloženo
+      authentication:
+        token:
+          interval:
+            description: Jak dlouho bude požadovaný token platný, v sekundách.
+            label: Interval
+          lifetime:
+            description: |-
+              fixed - token má pevnou dobu platnosti a nelze ho obnovit
+              renewable_manual - token lze obnovit, ale musí se obnovit ručně akcí renew
+              renewable_auto - token se při každém použití automaticky obnoví na now+interval
+              permanent - token bude platný navždy, dokud nebude smazán
+            label: Životnost
+          password:
+            label: Heslo
+          scope:
+            label: Rozsah
+          user:
+            label: Uživatel
+      default:
+        count:
+          label: Vrátit počet všech položek
+        total_count:
+          label: Celkový počet všech položek
+      metadata:
+        'no':
+          label: Zakázat metadata
+      paginable:
+        from_id:
+          description: Vypsat objekty s větším/menším ID
+          label: Od ID
+        limit:
+          description: Počet objektů k načtení
+          label: Limit
+    types:
+      invalid_boolean: neplatná pravdivostní hodnota %{value}
+      invalid_datetime: není ve formátu ISO 8601 '%{value}'
+      invalid_float: neplatné desetinné číslo %{value}
+      invalid_integer: neplatné celé číslo %{value}
+      invalid_string: neplatný řetězec %{value}
+    validation:
+      cannot_be_null: nesmí být null
+      includes_only_strings: includes musí obsahovat jen řetězce
+      includes_string_or_array: includes musí být řetězec nebo pole
+      input_parameters_not_valid: vstupní parametry nejsou platné
+      invalid_id: neplatné ID %{value}
+      invalid_input_layout: neplatná struktura vstupu
+      invalid_path_parameter_encoding: neplatné kódování parametru cesty
+      invalid_string_encoding: neplatné kódování řetězce
+      required_parameter_missing: povinný parametr chybí
+      resource_not_found: prostředek nebyl nalezen
+    validators:
+      acceptance:
+        accepted: musí být %{value}
+      confirmation:
+        different: musí být odlišné od %{parameter}
+        same: musí být stejné jako %{parameter}
+      exclusion:
+        excluded: "%{value} nelze použít"
+      format:
+        invalid: "%{value} nemá platný formát"
+      inclusion:
+        included: "%{value} nelze použít"
+      length:
+        equals: délka musí být %{equals}
+        max: délka může být nejvýše %{max}
+        min: délka musí být alespoň %{min}
+        range: délka musí být v rozsahu <%{min}, %{max}>
+      numericality:
+        composite: "%{requirements}"
+        even: sudé číslo
+        max: musí být nejvýše %{max}
+        min: musí být alespoň %{min}
+        mod: zbytek po dělení %{mod} musí být nula
+        number: musí být číslo
+        odd: liché číslo
+        range: musí být v rozsahu <%{min}, %{max}>
+        step: v krocích po %{step}
+      presence:
+        non_empty: musí být vyplněno a neprázdné
+        present: musí být vyplněno

data/lib/haveapi/locales/en.yml

@@ -0,0 +1,168 @@
+# This file is generated from i18n/haveapi.yml.
+# Do not edit it manually; manual changes will be overwritten.
+# Update i18n/haveapi.yml and run bundle exec rake i18n:update.
+---
+en:
+  haveapi:
+    action_state:
+      cancellation_failed: cancellation failed
+      not_found: action state not found
+      timeout_max: timeout has to be maximally %{max}
+    authentication:
+      failed: authentication failed
+      invalid_credentials: invalid authentication credentials
+      multiple_oauth2_tokens: Multiple OAuth2 tokens provided
+      multiple_tokens: Multiple authentication tokens provided
+      renew_failed: renew failed
+      required: Action requires user to authenticate
+      revoke_failed: revoke failed
+      token_required: Action requires user to authenticate with a token
+    authorization:
+      insufficient_permissions: Access denied. Insufficient permissions.
+    errors:
+      action_not_found: Action not found
+      bad_accept_header: Bad Accept header
+      bad_json_syntax: Bad JSON syntax
+      json_body_object: JSON body must be an object
+      server_error: Server error occurred
+      unsupported_content_type: Unsupported Content-Type
+    pagination:
+      limit_max: limit has to be maximally %{max}
+    parameters:
+      action_state:
+        can_cancel:
+          description: When true, execution of this action can be cancelled
+          label: Can cancel
+        created_at:
+          label: Created at
+        current:
+          label: Current progress
+        finished:
+          label: Finished
+        label:
+          label: Label
+        poll:
+          current:
+            description: progress to check with if update_in is set
+          status:
+            description: status to check with if update_in is set
+          timeout:
+            description: in seconds
+            label: Timeout
+          total:
+            description: progress to check with if update_in is set
+          update_in:
+            description: number of seconds after which the state is returned if the
+              progress has changed
+            label: Progress
+        status:
+          description: Determines whether the action is proceeding or failing
+          label: Status
+        total:
+          description: The action is finished when current equals to total
+          label: Total
+        unit:
+          description: Unit of current and total
+          label: Unit
+        updated_at:
+          description: When was the progress last updated
+          label: Updated at
+      action_state_id:
+        description: ID of ActionState object for state querying. When null, the action
+          is not blocking for the current invocation.
+        label: Action state ID
+      active_record:
+        includes:
+          description: |-
+            A list of names of associated resources separated by a comma.
+            Nested associations are declared with '__' between resource names.
+            For example, 'user,node' will resolve the two associations.
+            To resolve further associations of node, use e.g. 'user,node__location',
+            to go even deeper, use e.g. 'user,node__location__environment'.
+          label: Included associations
+        path_params:
+          description: An array of parameters needed to resolve URL to this object
+          label: URL parameters
+        resolved:
+          description: True if the association is resolved
+          label: Resolved
+      authentication:
+        token:
+          interval:
+            description: How long will requested token be valid, in seconds.
+            label: Interval
+          lifetime:
+            description: |-
+              fixed - the token has a fixed validity period, it cannot be renewed
+              renewable_manual - the token can be renewed, but it must be done manually via renew action
+              renewable_auto - the token is renewed automatically to now+interval every time it is used
+              permanent - the token will be valid forever, unless deleted
+            label: Lifetime
+          password:
+            label: Password
+          scope:
+            label: Scope
+          user:
+            label: User
+      default:
+        count:
+          label: Return the count of all items
+        total_count:
+          label: Total count of all items
+      metadata:
+        'no':
+          label: Disable metadata
+      paginable:
+        from_id:
+          description: List objects with greater/lesser ID
+          label: From ID
+        limit:
+          description: Number of objects to retrieve
+          label: Limit
+    types:
+      invalid_boolean: not a valid boolean %{value}
+      invalid_datetime: not in ISO 8601 format '%{value}'
+      invalid_float: not a valid float %{value}
+      invalid_integer: not a valid integer %{value}
+      invalid_string: not a valid string %{value}
+    validation:
+      cannot_be_null: cannot be null
+      includes_only_strings: includes must contain only strings
+      includes_string_or_array: includes must be a string or array
+      input_parameters_not_valid: input parameters not valid
+      invalid_id: not a valid id %{value}
+      invalid_input_layout: invalid input layout
+      invalid_path_parameter_encoding: invalid path parameter encoding
+      invalid_string_encoding: invalid string encoding
+      required_parameter_missing: required parameter missing
+      resource_not_found: resource not found
+    validators:
+      acceptance:
+        accepted: has to be %{value}
+      confirmation:
+        different: must be different from %{parameter}
+        same: must be the same as %{parameter}
+      exclusion:
+        excluded: "%{value} cannot be used"
+      format:
+        invalid: "%{value} is not in a valid format"
+      inclusion:
+        included: "%{value} cannot be used"
+      length:
+        equals: length has to be %{equals}
+        max: length has to be maximally %{max}
+        min: length has to be minimally %{min}
+        range: length has to be in range <%{min}, %{max}>
+      numericality:
+        composite: "%{requirements}"
+        even: even
+        max: has to be maximally %{max}
+        min: has to be minimally %{min}
+        mod: mod %{mod} must equal zero
+        number: has to be a number
+        odd: odd
+        range: has to be in range <%{min}, %{max}>
+        step: in steps of %{step}
+      presence:
+        non_empty: must be present and non-empty
+        present: must be present