has_helpers 5.0.2

data/lib/has_helpers/active_record.rb

@@ -0,0 +1,520 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "active_record"
+require "humanize"
+
+require "has_helpers/active_record/base"
+require "has_helpers/active_record/nested_resource"
+require "has_helpers/active_record/date_range"
+require "has_helpers/active_record/validation"
+
+module HasHelpers
+  HISTORY_MAX = 15
+
+  mattr_accessor :recently_viewed_resources
+
+  module ActiveRecord
+    include HasHelpers::ActiveRecordUtils
+    # Lookup for models
+    # @param [Hash] params The attribute:values that are used for the lookup
+    # @param [Hash] organization_id The value that are used for improve the lookup and only search in a determined organization
+    # @param [Hash] scope Additional scope for the lookup, defining joins, where clauses, and logical conditions.
+    # @param [String] condition The condition with which the lookup is performed (AND/OR). Default value is and.
+    # @param [String] show_error Boolean - Flag to indicate whether to show error messages or return nil when there are multiple or no results.
+    # @param [String] return_multiple Boolean - Flag to indicate whether to return all the models found or not.
+    # @param [Boolean] case_sensitive Boolean - Flag to indicate whether the lookup operation should be case-sensitive or case-insensitive.
+    # @return [Class/nil/String] Returns model instance or nil - The result of the lookup operation. If a single record is found, the instance is returned; otherwise, returns nil or an error message based on the show_error flag.
+
+    def lookup(params, organization_id, scope: nil, condition: LogicalOperator::AND, show_error: false, return_multiple: false, case_sensitive: true)
+      model = nil
+      if params.is_a? Hash
+        params.each do |key, _value|
+          association_values = key.to_s.split(".")
+          if !self.has_attribute?(key)
+            params = params.except(key) unless association_values.size > 1 && is_valid_association(association_values)
+          end
+        end
+        if params.any?
+          if condition == LogicalOperator::OR
+            model = add_joins(params, self, organization_id)
+            model = query_condition(params, case_sensitive, model, LogicalOperator::OR)
+          end
+
+          if condition == LogicalOperator::AND
+            model = add_joins(params, self, organization_id)
+            model = query_condition(params, case_sensitive, model)
+          end
+        end
+      else
+        model = lookup_by_attributes_precedence(params, organization_id, case_sensitive, return_multiple)
+      end
+      # scope example: [
+      # {:joins=>{:policies=>:advisors}, :where=>{:advisors=>{:npn=>11111529}}},
+      # {:joins=>{:policy_holders=>[{:policy=>{:writing_advisors=>:contract}}]}, :where=>{:"contracts.individual_number"=>"V1BUZ9J44XGJHF", :"contracts.corporate_number"=>"V1BUZ9J44XGJHF"}, :condition=>"or"}]
+      if scope.present?
+        scope.each do |item|
+          # join tables if specified in the scope item
+          model = model.joins(item[:joins]) if item[:joins].present?
+          if item[:condition].present? && item[:condition] == LogicalOperator::OR
+            model = query_condition(item[:where], case_sensitive, model, LogicalOperator::OR)
+          else
+            model ||= self
+            model = model.where(item[:where]) # LogicalOperator::AND by default
+          end
+        end
+      end
+      if return_multiple
+        ::ActiveRecord::Base.transaction do
+          return model.presence || []
+        rescue => e
+          ::ActiveRecord::Base.connection.rollback_db_transaction
+          error_message = "SQL error in #{__method__}: #{e.message}"
+          if show_error
+            return error_message
+          else
+            Rails.logger.info error_message
+          end
+          []
+        end
+      else
+        ::ActiveRecord::Base.transaction do
+          model = model.limit(2) unless model.nil? # Limiting the query to retrieve a maximum of 2 records for improved performance and to prevent unnecessary processing.
+          model.present? && model.size == 1 ? model.first : (show_error ? (model.present? && model.size > 1 ? "Multiple found." : "Not found.") : nil)
+        rescue => e
+          # In case of errors for example when we iterate over the lookup_attributes_precedence and try to match
+          # an string with an uuid (id), avoid the error and continue looking for the next attribute
+          ::Rails.logger.info "SQL error in #{__method__}: #{e.message}"
+          ::ActiveRecord::Base.connection.rollback_db_transaction
+          nil
+        end
+      end
+    end
+
+    def lookup_by_attributes_precedence(params, organization_id, case_sensitive, return_multiple)
+      model = nil
+      value = params
+      self.lookup_attributes_precedence.each do |_key, lookup_attribute|
+        model_found = false
+        joins = lookup_attribute.split(".")
+        query = self
+
+        # We don’t add organization_id in the query if organization_id is present in lookup_attributes_precedence, because organization_id is no longer in users.
+        query = query.where(organization_id: organization_id) if organization_id.present? && !organization_attribute_exist?
+
+        if joins.size > 1
+          joins[0...-1].each do |join_table|
+            table_name = self.reflect_on_association(join_table.singularize.to_sym)&.klass ? join_table.singularize.to_sym : join_table.to_sym # only singularize association if it's needed
+            query = query.joins(table_name) # the join need to be singularized and the where query uses the full string as 'demographics.ssn'
+          end
+        end
+
+        if case_sensitive || lookup_attribute.to_s.include?("id") || [:text, :string].exclude?(get_column_type(lookup_attribute))
+          model = query.where("#{lookup_attribute} = :param_value", param_value: value.to_s)
+        else
+          model = query.where("LOWER(#{lookup_attribute}) = :param_value", param_value: value.to_s.downcase)
+        end
+        ::ActiveRecord::Base.transaction do
+          model = model.limit(2) if model && !return_multiple # Limiting the query to retrieve a maximum of 2 records for improved performance and to prevent unnecessary processing.
+          model_found = true if model.length > 0
+        rescue => e
+          # In case of errors for example when we iterate over the lookup_attributes_precedence and try to match
+          # an string with an uuid (id), avoid the error and continue looking for the next attribute
+          ::Rails.logger.info "SQL error in #{__method__}: #{e.message}"
+          ::ActiveRecord::Base.connection.rollback_db_transaction
+          model = nil
+          model_found = false
+        end
+        break if model_found
+      end
+      model
+    end
+
+    def is_valid_association(association_values)
+      # the association needs to be singular, example for Clients : "demographic.ssn"
+      # the association would be "demographic" and the column name "ssn"
+      validation = self
+      association_values_without_last = association_values[0...-1] # Create a new array without the last element
+      column_name = association_values.last
+      association_values_without_last.each do |association|
+        validation = self.reflect_on_association(association.singularize.to_sym)&.klass
+        validation ||= self.reflect_on_association(association.to_sym)&.klass
+      end
+      validation&.column_names&.include?(column_name)
+    end
+
+    # Returns an array of valid columns for extraction search, such as advisor_id and advisor_import_key.
+    # The optional 'prefix' parameter appends a prefix to each column name (prefix + lookup attribute precedence),
+    # e.g., advisor_id, client_id, firm_id.
+    # When multi is set, the function generates columns with instance numbers,
+    # e.g., advisor_one_id, advisor_two_id, up to multi (advisor_multi_id).
+    def supported_columns_lookup(prefix = nil, multi = nil)
+      @prefix_supported_columns ||= {}
+      @prefix_supported_columns ["#{prefix}, #{multi}"] ||=
+        begin
+          keys_without_prefix = self.lookup_attributes_precedence.keys
+          return prefix.present? ? keys_without_prefix.map { |column| [prefix, column].join("_") } : keys_without_prefix.map(&:to_s) unless multi
+
+          keys_supported_columns = []
+          (1..multi).each do |n|
+            digit = n.humanize.underscore.despace
+            keys_without_prefix.each do |key|
+              keys_supported_columns << [prefix, digit, key].compact.join("_")
+            end
+          end
+          keys_supported_columns
+        end
+    end
+
+    # In case we have a nested association and an organization_id , iterate over and add the neccessary joins
+    def add_joins(params, query, organization_id)
+      params.each do |key, _value|
+        joins = key.to_s.split(".")
+        if joins.size > 1
+          joins[0...-1].each do |join_table|
+            association_klass = ::HasHelpers::ApplicationHelper.translate_klass_name(join_table.singularize.capitalize).safe_constantize
+            table_name = self.reflect_on_association(join_table.singularize.to_sym)&.klass ? join_table.singularize.to_sym : join_table.to_sym # only singularize association if it's needed
+            query = query.joins(table_name)
+            query = query.where("#{join_table}.organization_id = (?)", organization_id) if organization_id.present? && association_klass.present? && association_klass.has_attribute?(:organization_id)
+          end
+        end
+      end
+      query = query.where(organization_id: organization_id) if organization_id.present? && params.any? && !organization_attribute_exist?
+      query
+    end
+
+    # This is a list of attributes of the model that will be used to search by.
+    # Each model should override this method to lookup by simple attribute. e.g. Advisor.lookup("123456", 4) where "123456" is the unique import_key
+    # Note that nested associations should be defined as: table_name.attribute e.g. demographics.ssn
+    # Example for Advisor -> lookup_attributes_precedence = { id: "id", import_key: "import_key", code_name: "demographics.code_name", ssn: "demographics.ssn"}
+
+    def lookup_attributes_precedence
+      @lookup_attributes_precedence ||= {
+        id: "id"
+      }
+    end
+
+    # Checks whether the lookup_attributes_precedence hash contains the key :organization_id.
+    # Returns true if the key exists
+    def organization_attribute_exist?
+      self.lookup_attributes_precedence.key?(:organization_id)
+    end
+
+    # An array of columns that should be ignored or excluded, by default is an empty array
+    def ignore_columns
+      []
+    end
+
+    def dn_columns
+      self.column_names.select { |item| item.end_with?("_dn") }
+    end
+
+    # returns the available columns for creating a new object of the model class.
+    def klass_available_columns
+      self.column_names + klass_belongs_to_available_columns - ignore_columns - dn_columns - metadata_colums
+    end
+
+    def klass_belongs_to_available_columns
+      self.reflections.select { |_association_name, reflection| reflection.macro == :belongs_to }&.keys # client -> client_status, firm, organization
+    end
+
+    # This method assign the data considering associations and user context.
+    # returns a hash containing the hydrated model and any associations with errors.
+    def assign_data(data, prefix: nil, current_user: nil, multi: nil)
+      klass = self
+      model = klass.new
+
+      reflections = klass.reflections # has_many, belons_to, has_one
+      date_columns = klass.columns.select { |column| column.type == :date }.map(&:name) # start_date, end_date
+      columns = klass.column_names - reflections&.keys - date_columns # name, is_adjustment, note
+
+      associations_with_errors = {}
+
+      columns.each do |column|
+        model[column] = data[key_with_prefix(column, prefix)] if data[key_with_prefix(column, prefix)].present?
+      end
+
+      date_columns.each do |column|
+        model.assign_attributes({ column.to_sym => data[key_with_prefix(column, prefix)] }) if data[key_with_prefix(column, prefix)].present?
+      end
+
+      if current_user.present?
+        model.organization = current_user&.organizations&.first
+        model.created_by_id = current_user&.id if model.has_attribute?("created_by_id")
+        model.updated_by_id = current_user&.id if model.has_attribute?("updated_by_id")
+      end
+
+      reflections.each do |association_name, reflection|
+        result = nil
+        if !metadata_colums.include?(association_name)
+          association = reflection.options[:class_name].present? ? reflection.options[:class_name].safe_constantize : (reflection.klass || reflection.active_record)
+          is_constant = association.include?(::HasHelpers::Constant)
+          if is_constant
+            if data[key_with_prefix("#{association_name}_id", prefix)].present?
+              model.send("#{association_name}=", association.lookup(id: data[key_with_prefix("#{association_name}_id", prefix)]))
+            else
+              constant_value = data[key_with_prefix(association_name, prefix)] || data[key_with_prefix("#{association_name}_name", prefix)] # examples: policy_holder_type, policy_holder_type_id, policy_holder_type_name because the association name is only 'policy_holder_type'
+              model.send("#{association_name}=", association.lookup(constant_value)) if constant_value.present?
+            end
+          else
+            case reflection.macro
+            when :belongs_to, :has_one
+              association_data = remove_prefix(association, data, prefix.present? ? "#{prefix}_#{association_name}" : association_name)
+              if association_data.any?
+                result = association.lookup(association_data, model&.organization_id)
+                result.nil? ? associations_with_errors[association_name] = association : model.send("#{association_name}=", result)
+              end
+            when :has_many
+              if multi.present?
+                (1..multi).each do |n|
+                  digit = n.humanize.underscore.despace
+                  association_name = association_name.singularize
+                  association_data = remove_prefix(association, data, prefix.present? ? "#{prefix}_#{association_name}_#{digit}" : "#{association_name}_#{digit}")
+                  if association_data.any?
+                    # TODO: improve for User model that no longer has organization_id
+                    result = model.has_attribute?(:organization_id) ? association.lookup(association_data, nil) : association.lookup(association_data, model&.organization_id)
+                    if result.present?
+                      model.send("#{association_name.pluralize}") << result
+                    else
+                      associations_with_errors[association] = association_name
+                    end
+                  end
+                end
+
+              end
+
+            end
+          end
+        end
+      end
+      {
+        model: model,
+        associations_with_errors: associations_with_errors
+      }
+    end
+
+    # Custom method for constructing AND/OR conditions based on input parameters
+    # params example: {:"organizations.id"=>8, :name=>"Gayla Barrows"}
+    def query_condition(params, case_sensitive, model = nil, condition = LogicalOperator::AND)
+      table_name = self.table_name
+      conditions = []
+      query_params = {}
+
+      params.each do |column, value|
+        column_name_query = column.to_s.tr(".", "_") # convert column names to a standardized format for consistency example: organizations.id -> :organizations_id, demographic.ssn -> :demographic_ssn
+        association_values = column.to_s.split(".")
+
+        # If the column is part of an association (e.g., demographics.name),
+        # use the column name as it is. If it's not an association (e.g., name, id, import_key),
+        # set the table_column as "#{table_name}.#{column}" (e.g., users.name, users.id, users.import_key).
+        table_column = association_values.size > 1 ? column : "#{table_name}.#{column}"
+
+        if case_sensitive || column.to_s.include?("id") || [:text, :string].exclude?(get_column_type(table_column))
+          conditions << "#{table_column} = :#{column_name_query}"
+        else
+          conditions << "LOWER(#{table_column}) = :#{column_name_query}"
+        end
+
+        # a hash of query parameters for use in the WHERE clause {:organizations_id=>1, :users_name=>"Naomi'Lynch"}
+        query_params[column_name_query.to_sym] = case_sensitive ? value : value.to_s.downcase
+      end
+
+      query = conditions.join(" #{condition} ") # "organizations.id = :organizations_id OR users.name = :users_name"
+      model.nil? ? where(query, query_params) : model.where(query, query_params)
+    end
+
+    def get_column_type(column_or_attribute)
+      model_name, column_name = column_or_attribute.to_s.split(".")
+
+      if model_name.blank? || column_name.blank?
+        return self.columns_hash[column_or_attribute]&.type
+      end
+
+      if model_name == self.table_name
+        return self.columns_hash[column_name]&.type
+      end
+
+      reflection = self.reflections[model_name&.singularize] || self.reflections[model_name]
+      class_name = reflection&.klass || model_name.classify.safe_constantize
+
+      class_name&.columns_hash&.dig(column_name)&.type
+    end
+
+    def has_recently_viewed(*resources)
+      ::HasHelpers.recently_viewed_resources = resources.map { |r| r.to_s.demodulize.tableize.to_sym }
+
+      class_eval do
+        # Returns the recently viewed records for the given association.
+        #
+        # Examples
+        #   class User < ActiveRecord::Base
+        #     has_recently_viewed :advisor, :policy, "HasOutlook::DiscussionTemplateConfig"
+        #   end
+        #   user = ::HasHelpers::User.find(id)
+        #
+        #   user.recently_viewed(:advisor)
+        #   user.recently_viewed(:discussion_template_config)
+        def recently_viewed(association_name)
+          select_clauses = ["recently_vieweds.*"]
+          join_clauses = []
+
+          resource_klass = ::HasHelpers::RecentlyViewed.reflect_on_association(association_name).klass
+          resource_base_klass = resource_klass.base_class
+
+          # Detect owner view
+          unless resource_base_klass.instance_variable_defined?(:@owner_column_names)
+            owner_relation_name = "owner_#{ resource_base_klass.table_name }_view"
+            resource_base_klass.instance_variable_set(:@owner_relation_name, owner_relation_name)
+
+            if resource_base_klass.respond_to?(:owner_klass) && resource_base_klass.owner_klass
+              resource_base_klass.instance_variable_set(:@owner_column_names, resource_base_klass.owner_klass.column_names)
+            elsif ::HasHelpers::ActiveRecord.relation_exists?(owner_relation_name) # Check if the owner view is present.
+              # Detect column names for owner view.
+              resource_base_klass.instance_variable_set(
+                :@owner_column_names,
+                Class.new(::ActiveRecord::Base) do
+                  self.table_name = owner_relation_name
+                end.column_names
+              )
+            else
+              # No owner view detected so join in the resource records
+              resource_base_klass.instance_variable_set(:@owner_relation_name, resource_base_klass.table_name)
+              resource_base_klass.instance_variable_set(
+                :@owner_column_names,
+                (resource_base_klass.column_names & %w[id name username number type])
+              )
+            end
+          end
+
+          # Add select clauses for owner columns.
+          owner_relation_name = resource_base_klass.instance_variable_get(:@owner_relation_name)
+          resource_base_klass.instance_variable_get(:@owner_column_names).each do |owner_column|
+            select_clauses << "#{ owner_relation_name }.#{ owner_column } AS owner_#{ owner_column }"
+          end
+
+          join_clauses << "INNER JOIN #{ owner_relation_name } ON #{ owner_relation_name }.id = recently_vieweds.#{ resource_base_klass.name.foreign_key }"
+          type_scope = ::HasHelpers::RecentlyViewed.where(owner_relation_name => { type: resource_klass }) if resource_klass != resource_base_klass
+
+          scope = ::HasHelpers::RecentlyViewed.
+            select(select_clauses.join(", ")).
+            joins(join_clauses.join(" ")).
+            where(created_by_id: id).
+            where(organization_id: organization_id). # this included so that we only include records from the user's primary organization
+          where("recently_vieweds.#{ resource_base_klass.name.foreign_key } IS NOT NULL").
+            limit(::HasHelpers::HISTORY_MAX) # Needed because STI parent classes may have more records than the limit, up to number_of_descendant_classes * history_max.
+
+          # type_scope may be nil or may scope to a sub-type, e.g. where(policies: { type: "Application" })
+          if type_scope
+            scope = scope.merge(type_scope)
+          end
+
+          scope
+        end
+
+        # this association is only used for the destroy callback
+        has_many :all_recently_viewed, dependent: :destroy, foreign_key: "created_by_id", class_name: "::HasHelpers::RecentlyViewed"
+      end
+
+      resources.each do |r|
+        base_resource_klass = r.to_s.classify.constantize
+
+        # Add association to the given resource class and all of its descendants.
+        [base_resource_klass, *base_resource_klass.descendants].each do |resource_klass|
+          resource_klass.class_eval do
+            has_many :all_recently_viewed, dependent: :destroy, class_name: "::HasHelpers::RecentlyViewed", foreign_key: r.to_s.singularize.foreign_key
+          end
+        end
+
+        ::HasHelpers::RecentlyViewed.class_eval do
+          belongs_to r.to_s.demodulize.singularize.underscore.to_sym, class_name: r.to_s.classify, optional: true
+
+          base_resource_klass.descendants.each do |descendant_klass|
+            belongs_to descendant_klass.name.demodulize.singularize.underscore.to_sym, foreign_key: r.to_s.singularize.foreign_key, optional: true
+          end
+        end
+      end
+    end
+
+    # Enable favorites
+    #
+    # === Examples
+    # Create a favorite with the default limit trigger and validation:
+    #    has_favorites limit: 5
+    #
+    # Create a favorite with a custom validation:
+    #    has_favorites validate_proc: ->(){ errors.add(:base, "Too many favorites") if limit > some_limit }
+    #
+    # Create a favorite with a custom limit trigger:
+    #       class LimitReportFavorites < ::HasHelpers::LimitFavorites
+    #         def trigger_function
+    #           <<-SQL
+    #             CREATE OR REPLACE FUNCTION public."#{function_name}"() RETURNS TRIGGER LANGUAGE plpgsql AS $function$
+    #               DECLARE
+    #                 row_limit INTEGER;
+    #                 nrows INTEGER;
+    #                 resource_id TEXT;
+    #               BEGIN
+    #                 row_limit := #{limit};
+    #
+    #                 SELECT
+    #                   COUNT(*) INTO nrows
+    #                 FROM favorites
+    #                 INNER JOIN report.reports AS reports ON reports.id = favorites.report_id
+    #                 WHERE favorites.created_by_id = NEW.created_by_id
+    #                 AND reports.resource_id = (SELECT r.resource_id FROM report.reports AS r WHERE r.id = NEW.report_id);
+    #
+    #                 IF nrows > row_limit THEN
+    #                   SELECT
+    #                     format('%s-%s', 'Report', NEW.report_id::text)
+    #                   INTO resource_id;
+    #
+    #                   RAISE NOTICE 'favorite limit: resource_id = %', resource_id;
+    #                   RAISE 'Exceeded favorite limit of % for %', row_limit, resource_id;
+    #                 END IF;
+    #
+    #                 RETURN NULL;
+    #               END
+    #             $function$;
+    #           SQL
+    #         end
+    #       end
+    #
+    #    has_favorites limit_trigger: ::LimitReportFavorites.new(limit: 5)
+    def has_favorites(limit: nil, validate_proc: nil, limit_trigger: nil)
+      class_name = self.name.demodulize
+      association_name = class_name.underscore.to_sym
+      foreign_key = class_name.foreign_key.to_sym
+
+      has_many :favorites, class_name: "::HasHelpers::Favorite", dependent: :destroy
+      ::HasHelpers::Favorite.belongs_to association_name, class_name: self.name, optional: true
+      ::HasHelpers::Favorite.has_owner association_name if ::HasHelpers::Favorite.respond_to?(:has_owner)
+
+      if limit
+        ::HasHelpers::LimitFavorites.triggers << ::HasHelpers::LimitFavorites.new(klass: self, limit: limit)
+
+        ::HasHelpers::Favorite.validate if: foreign_key do
+          if ::HasHelpers::Favorite.where(created_by_id: created_by_id).where.not(foreign_key => nil).count >= limit
+            errors.add(association_name, "Favorites are limited to #{limit} per #{association_name}.")
+          end
+        end
+      end
+
+      if validate_proc
+        ::HasHelpers::Favorite.validate(if: foreign_key, &validate_proc)
+      end
+
+      if limit_trigger
+        ::HasHelpers::LimitFavorites.triggers << limit_trigger
+      end
+    end
+
+    # TODO remove this in the future when elastic search or web services are implemented
+    def self.relation_exists?(relation_name)
+      ::ActiveRecord::Base.connection.execute("SELECT 1 FROM #{ relation_name } LIMIT 1") rescue false
+    end
+  end
+end
+
+::ActiveRecord::Base.extend(::HasHelpers::ActiveRecord)
+::ActiveRecord::Base.extend(::HasHelpers::ActiveRecord::DateRange)
+::ActiveRecord::Base.extend(::HasHelpers::ActiveRecord::Validation)

data/lib/has_helpers/app/command.rb

@@ -0,0 +1,107 @@
+# typed: false
+# frozen_string_literal: true
+
+require "delegate"
+
+module App
+  module Command
+    class FailureError < StandardError; end
+
+    Result = Struct.new(:explicit_value, :error, :exception) do
+      attr_accessor :failed, :explicit_value_is_set
+
+      # Accept Hash values for attributes.
+      #   Result.new(error: "Something bad happened")  # => #<struct value=nil, error="Something bad happened">
+      #   Result.new(invalid_attr: nil)  # => ArgumentError: Unknown struct member: :invalid_attr
+      def initialize(**attrs)
+        unknown_attrs = attrs.keys - self.class.members
+        raise ::ArgumentError, "Unknown struct member#{ unknown_attrs.length == 1 ? "" : "s" }: #{ unknown_attrs.map(&:inspect).join(", ") }" unless unknown_attrs.empty?
+        super(*attrs.values_at(*self.class.members))
+      end
+
+      def fail(msg = nil)
+        self.failed = true
+        self.error ||= msg
+      end
+
+      def fail!(msg = nil)
+        fail(msg)
+        raise FailureError, error
+      end
+
+      def value=(v)
+        self.explicit_value_is_set = true
+        self.explicit_value = v
+      end
+
+      def value
+        explicit_value
+      end
+    end
+
+    class ResultProxy < ::SimpleDelegator
+      def success?
+        !(failed || error)
+      end
+    end
+
+    def self.included(klass)
+      unless klass.method_defined?(:run)
+        klass.include(StubbedRunInstanceMethod)
+      end
+
+      klass.prepend(MaskingInstanceMethods)
+      klass.extend(ClassMethods)
+
+      klass.class_eval do
+        attr_writer :result
+        private :result= # We don't want users to set the result object, so it is made private (not that it would _really_ stop them from doing so).
+      end
+    end
+
+    module StubbedRunInstanceMethod
+      # Provides a default method which can serve as the super method for the masking method.
+      def run(...)
+        raise ::NotImplementedError
+      end
+    end
+
+    module MaskingInstanceMethods
+      # Mask the user-defined (or stubbed) run method and wrap it with some functionality.
+      # This provides a Result object which is accessible within the user-defined run method.
+      # This method should never raise an exception, but rather it should always return a result.
+      def run(...)
+        # Execute the user-defined run method.
+        begin
+          run_return_value = super(...)
+          result.value = run_return_value unless result.explicit_value_is_set
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          result.error = e.message
+          result.exception = e
+        end
+
+        # Return the result.
+        ResultProxy.new(result)
+      end
+
+      def result
+        @result ||= Result.new
+      end
+
+      # Delegate fails to the result object.
+      def fail(*args)
+        result.fail(*args)
+      end
+
+      def fail!(*args)
+        result.fail!(*args)
+      end
+    end
+
+    module ClassMethods
+      def run(...)
+        new.run(...)
+      end
+    end
+  end
+end

data/lib/has_helpers/app.rb

@@ -0,0 +1,10 @@
+# typed: true
+# frozen_string_literal: true
+
+require "has_helpers/app/command"
+
+module App
+  def self.eager_load!
+    Zeitwerk::Loader.eager_load_all
+  end
+end

data/lib/has_helpers/assets_precompile_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module AssetsPrecompileHelper
+    class << self
+      def is_precompiling_assets?
+        !!(::Rake.try(:application)&.try(:top_level_tasks)&.select { |task| task =~ /^assets\:/ }&.any?)
+      end
+
+      def mock_sidekiq_limiters
+        require "sidekiq"
+        require "sidekiq-ent"
+        Sidekiq::Limiter.singleton_class.prepend(Module.new do
+          def concurrent(...); end
+          def window(...); end
+        end)
+      end
+    end
+  end
+end