has_helpers 5.0.2

data/app/controllers/has_helpers/factory_controller.rb

@@ -0,0 +1,261 @@
+# typed: false
+# frozen_string_literal: true
+
+module HasHelpers
+  # Test-only API for exercising ::FactoryBot factories from e2e suites.
+  class FactoryController < ActionController::API
+    around_action :run_inline_sidekiq
+    before_action :ensure_enabled!
+    before_action :authenticate!
+    before_action :load_factories
+
+    rescue_from StandardError, with: :handle_error
+
+    def create
+      config = factory_request_config
+      record = create_record(config[:factory], config[:traits], config[:overrides])
+      render json: serialize(record, config[:includes]), status: :created
+    end
+
+    def build
+      config = factory_request_config
+      record = build_record(config[:factory], config[:traits], config[:overrides])
+      render json: serialize(record, config[:includes]).merge(persisted: record.persisted?), status: :ok
+    end
+
+    def seed
+      config = factory_request_config
+      count = params.require(:count).to_i
+      raise ArgumentError, "count must be greater than 0" unless count.positive?
+
+      records = create_records(config[:factory], count, config[:traits], config[:overrides])
+      render json: records.map { |record| serialize(record, config[:includes]) }, status: :created
+    end
+
+    def show
+      record = find_record(params.require(:resource).to_sym, params.require(:id))
+      return head :not_found unless record
+
+      render json: serialize(record, parse_includes(params[:include])), status: :ok
+    rescue ::FactoryBot::FactoryNotRegisteredError, NameError => e
+      render json: { error: e.message }, status: :bad_request
+    rescue ActiveRecord::RecordNotFound, ActiveRecord::StatementInvalid
+      head :not_found
+    end
+
+    def scenario
+      scenario_def = ::HasHelpers::FactoryScenario.registry.fetch(params.require(:scenario))
+      return head :not_found unless scenario_def
+
+      runner = ::HasHelpers::FactoryScenario::Runner.new(
+        scenario_def,
+        params[:objects] || {},
+        params[:activate] || [],
+        params[:response] || []
+      )
+      result_objects = runner.run
+      render json: serialize_scenario_payload(result_objects, runner.explicit_keys), status: :ok
+    rescue StandardError => e
+      handle_error(e)
+    end
+
+    private
+
+    def factory_request_config
+      factory = params.require(:resource).to_sym
+      traits = Array(params[:traits]).map(&:to_sym)
+      overrides = params[:payload].presence || {}
+
+      # Permit any overrides; this endpoint is only available in test.
+      overrides = overrides.respond_to?(:to_unsafe_h) ? overrides.to_unsafe_h : overrides
+      overrides = merge_organization(overrides, factory)
+
+      { factory: factory, traits: traits, overrides: overrides, includes: parse_includes(params[:include]) }
+    end
+
+    def create_record(factory, traits, overrides)
+      record = ::FactoryBot.create(factory, *traits, **overrides)
+      record.reload if record.respond_to?(:reload)
+      reindex_records(factory, [record])
+      record
+    end
+
+    def build_record(factory, traits, overrides)
+      ::FactoryBot.build(factory, *traits, **overrides)
+    end
+
+    def create_records(factory, count, traits, overrides)
+      records = ::FactoryBot.create_list(factory, count, *traits, **overrides)
+      reindex_records(factory, records)
+      records
+    end
+
+    def find_record(factory, id)
+      model_class_for(factory).find_by(id: id)
+    end
+
+    def model_class_for(factory)
+      ::FactoryBot.factories.find(factory).build_class
+    end
+
+    def serialize(record, includes = nil)
+      if record.respond_to?(:attributes)
+        {
+          id: record.id,
+          attributes: record.as_json(include: includes)
+        }
+      elsif record.respond_to?(:id)
+        {
+          id: record.id,
+          attributes: record.as_json
+        }
+      else
+        { value: record }
+      end
+    end
+
+    def ensure_enabled!
+      head :not_found unless HasHelpers::FactoryApi.enabled?
+    end
+
+    def authenticate!
+      provided = request.headers[HasHelpers::FactoryApi::HEADER]
+      head :unauthorized unless HasHelpers::FactoryApi.authenticated?(provided)
+    end
+
+    # Accepts comma-separated string, JSON array, or nested hash structures.
+    def parse_includes(raw)
+      return nil if raw.blank?
+
+      raw = raw.to_unsafe_h if defined?(ActionController::Parameters) && raw.is_a?(ActionController::Parameters)
+
+      return parse_string_includes(raw) if raw.is_a?(String)
+      return parse_array_includes(raw) if raw.is_a?(Array)
+      return parse_hash_includes(raw) if raw.is_a?(Hash)
+
+      nil
+    end
+
+    def parse_string_includes(raw)
+      parsed = JSON.parse(raw)
+      parse_includes(parsed)
+    rescue JSON::ParserError
+      tokens = raw.split(",").map { |value| value.strip.to_sym }
+      tokens.length == 1 ? tokens.first : tokens.presence
+    end
+
+    def parse_array_includes(raw)
+      parsed = raw.map do |value|
+        value = value.to_unsafe_h if defined?(ActionController::Parameters) && value.respond_to?(:to_unsafe_h)
+        parsed_value = parse_includes(value)
+        collapse_single_item_array(parsed_value)
+      end.compact
+
+      parsed.presence
+    end
+
+    def collapse_single_item_array(value)
+      return value unless value.is_a?(Array) && value.length == 1 && !value.first.is_a?(Hash)
+
+      value.first
+    end
+
+    def parse_hash_includes(raw)
+      includes_hash = raw.deep_symbolize_keys
+      return parse_hash_include_key(includes_hash[:include]) if includes_hash.key?(:include)
+
+      includes_hash.transform_values do |value|
+        nested = parse_includes(value)
+        nested ? { include: nested } : {}
+      end
+    end
+
+    def parse_hash_include_key(raw)
+      nested = parse_includes(raw)
+      nested ? { include: nested } : {}
+    end
+
+    def per_object_includes
+      raw = params[:include]
+      return {} unless raw.is_a?(ActionController::Parameters) || raw.is_a?(Hash)
+
+      includes_hash = raw.respond_to?(:to_unsafe_h) ? raw.to_unsafe_h : raw
+      includes_hash.transform_keys(&:to_sym)
+    end
+
+    # Scenario responses support object-specific include trees only.
+    def serialize_scenario_payload(result_objects, explicit_keys)
+      selected_aliases = scenario_selected_aliases(result_objects, explicit_keys)
+      includes_by_alias = per_object_includes
+
+      result_objects.each_with_object({}) do |(alias_name, value), payload|
+        next unless selected_aliases.include?(alias_name)
+
+        includes = parse_includes(includes_by_alias[alias_name])
+        payload[alias_name] = serialize(value, includes)
+      end
+    end
+
+    def scenario_selected_aliases(result_objects, explicit_keys)
+      response_aliases = Array(params[:response]).map(&:to_sym)
+      return response_aliases if response_aliases.present?
+      return explicit_keys if explicit_keys.present?
+
+      result_objects.keys
+    end
+
+    def merge_organization(overrides, factory)
+      return overrides unless overrides.key?("organization_id") || overrides.key?(:organization_id)
+
+      model_class = model_class_for(factory)
+
+      organization = HasHelpers::Organization.find(overrides["organization_id"] || overrides[:organization_id])
+
+      overrides.delete("organization_id")
+      overrides.delete(:organization_id)
+
+      if model_accepts_organization?(model_class)
+        overrides.merge(organization: organization)
+      elsif model_class.name == HasHelpers::User.name
+        overrides.merge(user_organizations: [FactoryBot.build(:user_organization, organization: organization, is_primary: true)])
+      else
+        overrides
+      end
+    end
+
+    def model_accepts_organization?(model_class)
+      model_class.respond_to?(:column_names) && model_class.column_names.include?("organization_id")
+    end
+
+    # Reindex records if their model defines a search_index.
+    def reindex_records(factory, records)
+      model_class = model_class_for(factory)
+      index_class = model_class.try(:search_index) rescue nil
+      return unless index_class
+
+      ids = Array(records).map(&:id)
+      return if ids.empty?
+
+      Sidekiq::ElasticsearchProcessBatch.new.perform(index_class.name, index_class.index_name, ids)
+      Sidekiq::ElasticsearchProcessBatch.new.perform(index_class.name, index_class.keyword_search_index_name, ids)
+    end
+
+    def handle_error(error)
+      Rails.logger.warn("Factory API error: #{error.class}: #{error.message}\n#{error.backtrace&.first(3)&.join("\n")}")
+      render json: { error: error.message }, status: :bad_request
+    end
+
+    def load_factories
+      ::HasHelpers::FactoryApi.load_rails_helper_if_present!
+    end
+
+    # Run the whole request within Sidekiq inline mode when available.
+    def run_inline_sidekiq
+      if defined?(::Sidekiq) && defined?(::Sidekiq::Testing) && ::Sidekiq::Testing.respond_to?(:inline!)
+        ::Sidekiq::Testing.inline! { yield }
+      else
+        yield
+      end
+    end
+  end
+end

data/app/controllers/has_helpers/graphql_extensions.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module GraphqlExtensions
+    def execute_graphql_schema(
+      schema,
+      current_user,
+      current_application: ::HasHelpers::Application.current_application(request),
+      skip_authorization: false,
+      **ctx
+    )
+      abilities ||= {}
+      context = {
+        authorize: ->(action, object, parent_klass = object.class) {
+          return true if skip_authorization
+          klass = parent_klass < ::ActiveRecord::Base ? parent_klass.base_class : parent_klass
+          ability = abilities[klass] ||= Ability.new(current_user, current_application, klass)
+          ability.can?(action, object)
+        },
+        current_application: current_application,
+        current_organization: current_user&.organization,
+        current_user: current_user,
+        request: self.request,
+        response: self.response,
+        **ctx
+      }
+
+      result = if params[:_json]
+        queries = params[:_json].map do |param|
+          {
+            query: param[:query],
+            context: context,
+            operation_name: param[:operationName],
+            variables: ensure_hash(param[:variables])
+          }
+        end
+        schema.multiplex(queries)
+      else
+        schema.execute(
+          params[:query],
+          context: context,
+          operation_name: params[:operationName],
+          variables: ensure_hash(params[:variables])
+        )
+      end
+
+      render json: result # , root: false
+    rescue => e
+      ::HasUtils::Env.run_on_environment excluded: [::HasUtils::Env::DEVELOPMENT] do
+        raise e
+      end
+      handle_error_in_development e
+    end
+
+    private
+
+    def handle_error_in_development(e)
+      logger.error e.message
+      logger.error e.backtrace.join("\n")
+
+      render json: { error: { message: e.message, backtrace: e.backtrace }, data: {} }, status: :internal_server_error
+    end
+
+    def ensure_hash(ambiguous_param)
+      case ambiguous_param
+      when String
+        if ambiguous_param.present?
+          ensure_hash(JSON.parse(ambiguous_param))
+        else
+          {}
+        end
+      when Hash
+        ambiguous_param
+      when ActionController::Parameters
+        ambiguous_param.to_unsafe_h
+      when nil
+        {}
+      else
+        raise ArgumentError, "Unexpected parameter: #{ambiguous_param}"
+      end
+    end
+  end
+end

data/app/controllers/has_helpers/health_check_controller.rb

@@ -0,0 +1,46 @@
+# typed: false
+# frozen_string_literal: true
+
+module HasHelpers
+  class HealthCheckController < ActionController::Base
+    def ping
+      logger.debug "in HealthCheckController#ping"
+      render json: { healthy: true, when: Time.current.iso8601 }
+    end
+
+    # the below two queries are needed because we have preemptible-vms
+    # and this busts the db cache https://cloud.google.com/preemptible-vms/
+
+    def pingdb
+      ::ActiveRecord::Base.connection.execute("SELECT 1") rescue false
+
+      logger.debug "in HealthCheckController#pingdb"
+      render json: { healthy: true, when: Time.current.iso8601 }
+    end
+
+    def pingwh
+      ::DataWarehouse.connection_pool.connection.execute("SELECT 1") rescue false
+      logger.debug "in HealthCheckController#pingwh"
+      render json: { healthy: true, when: Time.current.iso8601 }
+    end
+
+
+    def pinggj
+      ::ActiveRecord::Base.connection.execute("SELECT 1") rescue false
+      ::GoodJob::Job.connection.exec_query("SELECT 1") rescue false
+      logger.debug "in HealthCheckController#pinggj"
+      render json: { healthy: true, when: Time.current.iso8601 }
+    end
+
+    def pingdbs
+      # the below two queries are needed because we have preemptible-vms
+      # and this busts the db cache https://cloud.google.com/preemptible-vms/
+      ::ActiveRecord::Base.connection.execute("SELECT 1") rescue false
+      ::DataWarehouse.connection_pool.connection.execute("SELECT 1") rescue false
+      ::GoodJob::Job.connection.exec_query("SELECT 1") rescue false
+
+      logger.debug "in HealthCheckController#pingdbs"
+      render json: { healthy: true, when: Time.current.iso8601 }
+    end
+  end
+end

data/app/controllers/has_helpers/search_extensions.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module HasHelpers::SearchExtensions
+  PROVIDER_CACHE_KEY = "has_helpers:search_provider"
+
+  def self.search_provider
+    if ::HasHelpers::Feature.active?(:sql_search)
+      ::HasHelpers::Search::SqlSearch
+    else
+      ::HasHelpers::Search::Elasticsearch
+    end
+  end
+
+  def self.search_provider=(provider = nil, &block)
+    previous_provider = @search_provider
+    @search_provider = provider || block
+    clear_search_provider_cache! unless previous_provider == @search_provider
+  end
+
+  def self.clear_search_provider_cache!
+    Rails.cache.delete(::HasHelpers::SearchExtensions::PROVIDER_CACHE_KEY)
+  end
+
+  def path_lookup_for(_only_result)
+    nil
+  end
+
+  private
+  def search_logic
+    provider = search_provider
+    results = provider.results
+
+    if results
+      prefix = provider.search_prefix
+      screen = provider.search_screen
+      show_type = screen =~ /global/ || screen&.classify&.safe_constantize&.descendants&.any?
+      search_presenter = ::HasHelpers::SearchPresenter.new(results, screen: screen, show_type: show_type)
+
+      # Render results
+      if params[:search_global] || params[:search_global_list]
+        respond_to do |format|
+          format.html do
+            if results.count == 1
+              only_result = results.first
+              redirect_to path_lookup_for(only_result)
+            else
+              no_results_found_redirect_url = nil
+              if results.count == 0 && self.respond_to?(:create_no_results_found_redirect_url)
+                no_results_found_redirect_url = create_no_results_found_redirect_url
+              end
+              current_layout  # Explicitly set the current layout because rendering here stops the filter chain.
+              render "/frameworkhq/utils/_find", locals: { search_presenter: search_presenter, no_results_found_redirect_url: no_results_found_redirect_url }
+            end
+          end
+          format.json do
+            render json: search_presenter.to_h
+          end
+          if params[:search_global_list]
+            format.js do
+              render "/frameworkhq/utils/_find", locals: { search_presenter: search_presenter }
+            end
+          else
+            search_presenter.multiscreen = params["search_#{ prefix }_multiscreen"].present?
+            format.js do
+              render "/shared/search/_results_items", locals: { search_presenter: search_presenter }
+            end
+          end
+        end
+      elsif request.xhr?
+        respond_to do |format|
+          format.js do
+            search_presenter.multiscreen   = params["search_#{ prefix }_multiscreen"].present?
+            search_presenter.search_submit = params["search_#{ prefix }_submit"]
+            if params["search_#{ prefix }_use_exact_submit"].present?
+              selected_screen = params["search_#{ prefix }_screen"]&.singularize
+              search_presenter.exact_submit = params["search_#{ prefix }_submit_for_#{ selected_screen }"]
+            end
+            render "/shared/search/_results_items", locals: { search_presenter: search_presenter }
+          end
+          format.json do
+            render json: search_presenter.to_h
+          end
+        end
+      end
+    end
+  end
+
+  # Returns an instance of a default search provider. To change this simply override the method.
+  def search_provider
+    ::HasHelpers::SearchExtensions.search_provider.new(self)  # search providers expect to be initialized with a controller instance.
+  end
+end

data/app/controllers/has_helpers/service_trust/jwks_controller.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module ServiceTrust
+    class JwksController < ActionController::API
+      def show
+        expires_in 1.hour, public: true
+        render json: { keys: KeyManager.verifiable_keys.map { |key| jwk(key) } }
+      end
+
+      private
+
+      def jwk(key)
+        JWT::JWK.new(key.public_key, kid: key.kid).
+          export.
+          merge(use: "sig", alg: key.algorithm)
+      end
+    end
+  end
+end

data/app/controllers/has_helpers/xlsx_export.rb

@@ -0,0 +1,115 @@
+# typed: false
+# frozen_string_literal: true
+
+require "spreadsheet_architect"
+
+module HasHelpers
+  module XlsxExport
+    VALID_AXLSX_VALUES = %i[string integer float date time boolean].freeze
+    AXLSX_SHEET_NAME_BYTE_LIMIT = 31
+    AXLSX_SHEET_NAME_CHARMAP = {
+      ?[ => ?(,
+      ?] => ?),
+      ?* => "",
+      ?/ => ?-,
+      ?\\ => ?-,
+      ?? => "",
+      ?: => "",
+    }.freeze
+
+    #=== Example
+    #   send_xlsx(
+    #     sheets: [
+    #       {
+    #         name: "Sheet 1",
+    #         data: [["Row1", 123], ["Row2", 456]],
+    #         headers: ["Name","Number"],
+    #         column_types: [:string,:number]
+    #       },{
+    #         name: "Sheet 2",
+    #         data: [["Row1", 123], ["Row2", 456]],
+    #         headers: ["Name","Number"],
+    #         column_types: [:string,:number]
+    #       }
+    #     ], # End :sheets
+    #     name: "My Report",          # Will result in the filename being "My Report.xlsx" (alternative to supplying the entire filename)
+    #     filename: "my-report.xlsx"  # :filename and :name should be used exclusively.
+    #   )
+    def send_xlsx(
+      sheets:,
+      name:      nil,
+      filename:  (name.present? || nil) && (/\.xlsx/.match?(name) ? name : "#{ name }.xlsx"),
+      **options
+    )
+      headers["Content-Disposition"] = %Q(attachment; filename="#{ filename }")
+      send_data(
+        axlsx_package_from_sheets(sheets: sheets, **options).to_stream.read,
+        filename: filename,
+        type: ::Mime[:xlsx].to_s
+      )
+    end
+
+    private
+
+    def axlsx_package_from_sheets(sheets:, **_options)
+      axlsx_package = nil
+      sheets = cleanup_sheets(sheets)
+      sheets.each.with_index do |sheet, idx|
+        sheet.symbolize_keys.tap do |sheet_keys|
+          name = sheet_keys[:name]
+          column_types = sheet_keys[:column_types]
+          sheet_options = sheet_keys.except(:name, :column_types)
+
+          axlsx_package = SpreadsheetArchitect.to_axlsx_package(
+            {
+              sheet_name: sanitize_sheet_name(name || "Sheet #{ idx + 1 }"),
+              **sheet_options,
+              column_types: column_types && get_axlsx_column_types(column_types)
+            },
+            *axlsx_package
+          )
+        end
+      end
+
+      axlsx_package  # Return this
+    end
+
+    # Return a valid Axlsx column type or nil (if a given column type does not match any of the valid values).
+    def get_axlsx_column_types(column_types)
+      column_types.map do |column_type|
+        # explicitly set type for decimal values as expected by axlsx so formula works
+        # else set to nil so axlsx will auto detect the cell type
+        type = column_type == "currency" ? :float : nil
+        VALID_AXLSX_VALUES.find { |v| v == type }
+      end
+    end
+
+    def sanitize_sheet_name(name)
+      name.dup.tap do |result|
+        # replace illegal characters
+        AXLSX_SHEET_NAME_CHARMAP.each do |k, v|
+          result.gsub!(k, v)
+        end
+
+        # truncate to byte limit. Could use a binary search here.
+        i = 0
+        while result[0..i].bytesize <= AXLSX_SHEET_NAME_BYTE_LIMIT && i < result.length
+          i += 1
+        end
+        result.slice!(i, result.length - i)
+      end  # Return result (via tap)
+    end
+
+    def cleanup_sheets(sheets)
+      sheet_names = sheets.map { |sheet| sheet[:name] }
+      duplicates = sheet_names.find_all { |x| sheet_names.count(x) > 1 }.uniq
+
+      duplicates.each do |duplicate|
+        first_duplicate_index = sheet_names.index(duplicate)
+        sheets.delete_at(first_duplicate_index)
+      end
+
+      sheets
+    end
+  end
+end

data/app/controllers/search_extensions.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SearchExtensions
+  module ProviderExtensions; end
+end

data/app/graphql/has_helpers/base_type.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class BaseType < ::GraphQL::Schema::Object
+    def current_organization
+      context[:current_organization]
+    end
+
+    def current_user
+      context[:current_user]
+    end
+  end
+end

data/app/graphql/has_helpers/base_union.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  class BaseUnion < ::GraphQL::Schema::Union
+    def self.resolve_type(object, _context)
+      ::HQ::GraphQL::Types[object.class]
+    end
+  end
+end

data/app/graphql/has_helpers/enums/resource_enum.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Enums
+    class ResourceEnum < ::GraphQL::Schema::Enum
+      graphql_name "ResourceEnum"
+
+      lazy_load do
+        current_application = ::HasHelpers::Application.current_application
+        next if !current_application
+
+        resources_by_name = current_application.resources.
+          where(parent_id: nil).
+          group_by(&:name)
+
+        resources_by_name.each do |name, resources|
+          resource = resources.first
+          clean_name = name.delete(" :")
+          value clean_name, value: resource
+        end
+      end
+    end
+  end
+end