has_helpers 5.0.2

data/app/commands/reports/generator.rb

@@ -0,0 +1,310 @@
+# typed: false
+# frozen_string_literal: true
+
+module Reports
+  module Generator
+    class GeneratorError < StandardError
+      ERROR_MSG = "%{error_type} ERROR (%{option_type} - %{option_name})"
+      MISSING_HAS_REPORTS_MSG = "Unable to generate report options for %{class_name}: missing has_reports"
+
+      # Allows for accumulating errors.
+      def initialize(full_error_list: nil)
+        full_message = full_error_list&.reject(&:blank?)&.join("\n")
+        super(full_message)
+      end
+
+      def self.create_backtrace_string(base_error: nil)
+        if base_error
+          [
+            "-" * 20,
+            base_error.message,
+            *base_error.backtrace.map { |line| "> #{ line }" }
+          ].join("\n")
+        else
+          nil
+        end
+      end
+
+      def self.create_error_message(msg: "", base_error: nil)
+        [
+          msg,
+          create_backtrace_string(base_error: base_error)
+        ].reject(&:blank?).join("\n")
+      end
+    end
+
+    # This is a scipt to run the options generator for a set of classes.
+    # It will generate the select options, filter options, and expansions for the
+    # given classes.
+    # This should be run on the project who wants ti use the reproting app.
+
+    #=== Arguments
+    # +klasses+: A collection of the classes for which options will be generated. Eg. `Generator.run([Advisor, Policy])`
+    #
+    #=== Options
+    # +:schema+:         Optional schema name. This will be the default schema for all table names.
+    #
+    #=== Examples
+    #   ::Reports::Generator.run(Advisor)
+    #   ::Reports::Generator.run_all --> to create resources and run for all flatteners
+    def self.run(
+      klasses,
+      # audit: true,
+      verbose: false,
+      **options
+    )
+      aggregate_errors = []
+
+      # Generate the options inside a transaction. This ensures that if there
+      # are any errors, we can rollback the entire generate, including any
+      # modifications made in the `before_generate` hook.
+      ::ActiveRecord::Base.transaction do
+        # if defined? @@before_generate_block
+        #   class_eval(&@@before_generate_block)
+        # end
+
+        begin
+          Array(klasses).each do |klass|
+            # Check klass for has_reports
+            # raise GeneratorError.new(full_error_list: GeneratorError::MISSING_HAS_REPORTS_MSG % { class_name: klass.name }) unless klass.has_reports(meta_only: true)
+            # just one request per class
+            # each time we run the generator we need to check if all flatteners are created on db as a resource
+            check_resources
+            response = Reports::ExternalGraphqlClient.query_resource_by_name(name: klass.name)
+            resource_id = response.dig("data", "resourceName", "id")
+            # Select options
+            begin
+              # first generate the resource if it doesnt exist
+              # call the mutation to generate the resource
+              select_option_attributes = generate_select_options(klass, resource_id, **options)
+              importer = ::Reports::Importer.new(resource_id, resource_name: klass.name, **options)
+              # select_option_attributes.uniq! { |attrs| attrs[:name] }  # FIXME: temporary work-around until duplicate entries are fixed - Gotta test those reports!!! *
+              errors = importer.import_select_options(select_option_attributes, resource_id, verbose: verbose)
+              if errors.any?
+                aggregate_errors.concat(errors)
+              end
+            rescue ::Reports::Importer::AuditError => e
+              aggregate_errors << GeneratorError.create_error_message(msg: GeneratorError::ERROR_MSG % { error_type: "AUDIT", option_type: "SelectOption", option_name: klass.name }, base_error: e)
+            end
+            # Filter options
+            begin
+              importer = ::Reports::Importer.new(resource_id, resource_name: klass.name, **options)
+              filter_option_attributes = generate_filter_options(klass, resource_id, **options)
+              # filter_option_attributes.uniq! { |attrs| attrs[:name] }  # FIXME: temporary work-around until duplicate entries are fixed - Gotta test those reports!!! *
+              errors = importer.import_filter_options(filter_option_attributes, resource_id, verbose: verbose)
+              if errors.any?
+                aggregate_errors.concat(errors)
+              end
+            rescue ::Reports::Importer::AuditError => e
+              aggregate_errors << GeneratorError.create_error_message(msg: GeneratorError::ERROR_MSG % { error_type: "AUDIT", option_type: "FilterOption", option_name: klass.name }, base_error: e)
+            end
+          end
+        rescue => e
+          aggregate_errors << GeneratorError.create_error_message(msg: "FATAL EXCEPTION", base_error: e)
+        end
+        # Return errors
+        aggregate_errors
+      end
+    end
+
+    def self.create_resources(klass_name = nil)
+      # This method is used to ensure that the resources are created in the database.
+      # It will create the resources if they do not exist.
+      # It will return an array of errors if any resources could not be created.
+      response_messages = []
+      if klass_name
+        response = Reports::ExternalGraphqlClient.query_resource_by_name(name: klass_name)
+        resource_id = response.dig("data", "resourceName", "id")
+        unless resource_id
+          # If not found, create it using the mutation
+          create_resource = Reports::ExternalGraphqlClient.create_resource(mutation_name: "createResource", input_name: "ReportResourceInput", attributes: { name: klass_name, type: "HasReports::Resource" })
+          if create_resource["errors"]
+            response_messages << "Failed to create resource for flattener #{klass_name}: #{create_resource["errors"]}"
+          else
+            response_messages << "Successfully created resource for flattener #{klass_name}"
+          end
+        end
+      else
+        flatteners = all_flattener_classes
+        flatteners.each do |flattener|
+          # Check if the resource exists via the external GraphQL client
+          flattener_name = flattener.name.sub(/^Flatteners::/, "") # Remove the Flatteners:: prefix
+          response = Reports::ExternalGraphqlClient.query_resource_by_name(name: flattener_name)
+          resource_id = response.dig("data", "resourceName", "id")
+          unless resource_id
+            # If not found, create it using the mutation
+            create_resource = Reports::ExternalGraphqlClient.create_resource(
+              mutation_name: "createResource",
+              input_name: "ReportResourceInput",
+              attributes: {
+                name: flattener_name,
+                type: "HasReports::Resource"
+              }
+            )
+            if create_resource["errors"]
+              response_messages << "Failed to create resource for flattener #{flattener_name}: #{create_resource["errors"]}"
+            else
+              response_messages << "Successfully created resource for flattener #{flattener_name}"
+            end
+          end
+        end
+      end
+      response_messages
+    end
+
+    def self.check_resources
+      # Fetch all resources with error handling
+      all_resources = Reports::ExternalGraphqlClient.query_all_resources
+      unless all_resources.key?("data")
+        Rails.logger.error "Failed to fetch resources: #{all_resources.inspect}"
+        return []
+      end
+      resource_array = all_resources.dig("data", "resources") || []
+      # Get all flattener classes more efficiently
+      flatteners = all_flattener_classes
+      # Extract resource names once
+      resource_names = (resource_array["edges"] || []).filter_map { |edge| edge["node"]&.dig("name")&.demodulize }.to_set
+      # Find and process missing flatteners
+      missing_flatteners = flatteners.each_with_object([]) do |flattener, arr|
+        flattener_name = flattener.name.demodulize
+        arr << flattener unless resource_names.include?(flattener_name)
+      end
+      # Create missing resources with logging
+      missing_flatteners.each do |flattener|
+        flattener_name = flattener.name.demodulize
+        next if flattener_name.blank?
+
+        create_resources(flattener_name)
+      end
+
+      missing_flatteners
+    end
+
+    def self.run_all
+      response_messages = []
+      flatteners = all_flattener_classes
+      flatteners.each do |flattener|
+        # Check if the resource exists via the external GraphQL client
+        flattener_name = flattener.name.sub(/^Flatteners::/, "") # Remove the Flatteners:: prefix
+        response = Reports::ExternalGraphqlClient.query_resource_by_name(name: flattener_name)
+        resource_name = response.dig("data", "resourceName", "name")
+        if resource_name.present?
+          run(resource_name.constantize) unless resource_name.to_s.demodulize == "UserOrganization"
+        else
+          # If not found, create it using the mutation
+          create_resource = Reports::ExternalGraphqlClient.create_resource(
+            mutation_name: "createResource",
+            input_name: "ReportResourceInput",
+            attributes: {
+              name: flattener_name,
+              type: "HasReports::Resource"
+            }
+          )
+          if create_resource["errors"]
+            response_messages << "Failed to create resource for flattener #{flattener_name}: #{create_resource["errors"]}"
+          else
+            resource_name = Reports::ExternalGraphqlClient.query_resource_by_name(name: flattener_name)
+            resource_name = resource_name.dig("data", "resourceName", "name")
+            klass = resource_name&.safe_constantize
+            if klass
+              run(klass)
+              response_messages << "Successfully created resource for flattener #{flattener_name}"
+            else
+              response_messages << "Resource created but class not found for #{flattener_name}"
+            end
+          end
+        end
+      end
+    end
+
+    def self.generate_select_options(klass, resource_id, **options)
+      results = []
+      results.concat(::Reports::BaseOptions.generate_select_options(klass, resource_id, **options).to_a)
+      results.concat(::Reports::ConstantOptions.generate_select_options(klass, **options).to_a)
+      results.concat(::Reports::BelongsToOptions.generate_select_options(klass, **options).to_a)
+      results.concat(::Reports::HasManyOptions.generate_select_options(klass, **options).to_a)
+      results.concat(::Reports::NestedAttributeOptions.generate_select_options(klass, **options).to_a)
+      results
+    end
+
+    def self.generate_filter_options(klass, resource_id, **options)
+      [].tap do |results|
+        results.concat(::Reports::BaseOptions.generate_filter_options(klass, **options).to_a)
+        results.concat(::Reports::ConstantOptions.generate_filter_options(klass, **options).to_a)
+        results.concat(::Reports::BelongsToOptions.generate_filter_options(klass, resource_id, **options).to_a)
+        results.concat(::Reports::HasManyOptions.generate_filter_options(klass, **options).to_a)
+        results.concat(::Reports::NestedAttributeOptions.generate_filter_options(klass, **options).to_a)
+      end
+    end
+
+    # Lists all flatteners defined by reading the filesystem.
+    # This is used to be able to obtain flattener names with prefixes like HasHelpers::Organization.
+    def self.all_flattener_classes
+      base_path = Rails.root.join("app/models/flatteners")
+      Dir.glob(base_path.join("**/*.rb")).filter_map do |path|
+        const_name = Pathname.new(path).
+          relative_path_from(base_path.parent).
+          to_s.
+          delete_suffix(".rb").
+          split("/").
+          map(&:camelize).
+          join("::")
+        const_name.safe_constantize
+      end.select { |c| c.is_a?(Class) && c < Flattener::Base }
+    end
+
+    def self.custom_select_options(klass, &block)
+      if block
+        previous_custom_select_options = custom_select_options_cache[klass]
+        custom_select_options_cache[klass] = proc do |results = []|
+          # Invoke the previous callback (if any)
+          previous_custom_select_options.call(results) if previous_custom_select_options
+          results.concat(block.call)
+        end
+      else
+        custom_select_options_cache[klass].nil? ? [] : custom_select_options_cache[klass].call
+      end
+    end
+
+    #=== Examples
+    #   # Removing redundant terms - in this case a second consecutive "Client" is removed.
+    #   build_option_name(:primary, :client, :client_id, preserve_id: false)  # => "Primary Client Id"
+    def self.build_option_name(*parts, column_type: nil, preserve_id: false)
+      # Create an enumerator which yields the words used to build the name.
+      words = Enumerator.new do |yielder|
+        parts.lazy.
+          map(&:to_s).
+          map do |part|
+          if column_type == "boolean"
+            part.gsub(/(^|_)is_/, '\1')
+          else
+            part
+          end
+        end.
+          map do |part|
+          if preserve_id
+            part.tr("_", " ") # Prevents titleize from removing "_id"
+          else
+            part
+          end
+        end.
+          map(&:titleize).
+          each do |part|
+          # Yield each word separately. E.g. "Client Id" => ["Client", "Id"]
+          part.split(/\s+/).each do |sub_part|
+            sub_part = sub_part.gsub("Id", "ID")
+            yielder << sub_part
+          end
+        end
+      end
+
+      # Get all the parts of the name, excluding consecutive repeated elements.
+      sanitized_parts = [*words.first] # Always include the first word
+      words.each_cons(2) do |part1, part2|
+        sanitized_parts << part2 unless part1 == part2
+      end
+
+      sanitized_parts.join(" ")
+    end
+  end
+end

data/app/commands/reports/has_many_options.rb

@@ -0,0 +1,105 @@
+# typed: false
+# frozen_string_literal: true
+
+module Reports
+  module HasManyOptions
+    # Generate select options (attributes) for all associations with nested
+    # attributes for the given class.
+    def self.generate_select_options(klass, nested_as: nil, **_options)
+      generate_options(
+        klass: klass,
+        type: "Select",
+        nested_as: nested_as
+      )
+    end
+
+    def self.generate_filter_options(klass, nested_as: nil, **_options)
+      generate_options(klass: klass, type: "Filter", nested_as: nested_as)
+    end
+
+    def self.flattener(klass)
+      Flattener.for(klass).pivot_or_self
+    end
+
+    # Returns a lazy enumerator which yields the belongs_to associations (only those available for reports) for the given class.
+    def self.has_many_associations(klass)
+      flattener(klass).associations.lazy.
+        reject(&:is_constant?).
+        reject(&:is_nested_attributes?).
+        select { |association| association.macro == :has_many }.
+        reject { |association| association.ar_association.through_reflection }.
+        reject { |association| association.flattener.class.is_pivot? }
+    end
+
+    def self.generate_options(klass:, type:, nested_as: nil, **_options)
+      Enumerator.new do |yielder|
+        # Yield a select option for each belongs to association
+        has_many_associations(klass).each do |association|
+          expansions = Array(association.expand_on)
+          assoc_name = build_resource_name(association.name).singularize
+          break if assoc_name == "Favorite"
+          association_resource_id = Reports::ExternalGraphqlClient.
+            query_resource_by_name(name: assoc_name)&.
+            dig("data", "resourceName", "id")
+          # to define the join resource, we need to define the join association on the flattener we let a commented example on projects
+          join_resource_id =
+            if association.join_resource.present?
+              Reports::ExternalGraphqlClient.
+                query_resource_by_name(name: build_resource_name(association.join_resource))&.
+                dig("data", "resourceName", "id")
+            end
+          # join_name = join_resource.dig("data", "resourceName", "name")
+          next if association_resource_id.blank?
+          association_and_descendants(association).each do |_association_klass, association_name|
+            expansions.each do |expansion|
+              option = {
+                name: ::Reports::Generator.build_option_name(*expansion, association_name),
+                associationResourceId: association_resource_id.to_i,
+                associationName: association_name,
+                associationColumnName: [*nested_as, association.foreign_key].join("_"),
+              }
+              option[:joinResourceId] = join_resource_id if join_resource_id.present?
+              option[:columnType] = "link" if type == "Select"
+              option[:selectOptionType] = "HasMany" if type == "Select"
+              option[:filterOptionType] = "HasMany" if type == "Filter"
+              yielder << option
+            end
+
+            option = {
+              name: ::Reports::Generator.build_option_name(association_name),
+              associationResourceId: association_resource_id.to_i,
+              associationName: association_name,
+              associationColumnName: [*nested_as, association.foreign_key].join("_"),
+            }
+            option[:joinResourceId] = join_resource_id if join_resource_id.present?
+            option[:columnType] = "link" if type == "Select"
+            option[:selectOptionType] = "HasMany" if type == "Select"
+            option[:filterOptionType] = "HasMany" if type == "Filter"
+            yielder << option
+          end
+        end
+      end
+    end
+
+    def self.build_resource_name(name)
+      Reports::Generator.build_option_name(name).delete(" ")
+    end
+
+    def self.association_and_descendants(association)
+      [
+        [association.klass, association.name.to_s],
+        *association.klass.descendants.map { |d| [d, format_descendent_name(d, association)] }
+      ]
+    end
+
+    # To avoid naming conflicts, suffix the descendant's name with the association
+    # unless the association's name matches the association's klass name
+    def self.format_descendent_name(descendant, association)
+      if association.name.to_s.classify == association.klass.name.demodulize
+        descendant.name.tableize
+      else
+        "#{descendant.name.underscore}_#{association.name}"
+      end
+    end
+  end
+end

data/app/commands/reports/importer.rb

@@ -0,0 +1,132 @@
+# typed: true
+# frozen_string_literal: true
+
+# TODO: Move lib/ out from under app/
+
+#=== Instantiating
+# To get an instance of an importer you must provide a resource (HasReports::Resource)
+# such as `Reports::Importer.new(resource: HasReports::Resource::MY_RESOURCE)
+module Reports
+  class Importer
+    AuditError = Class.new(::StandardError)
+
+    include ::HasHelpers::Attributes # For assignment of attributes passed to initialize, e.g. `Reports::Importer.new(resource: my_resource)`
+
+    RESOURCE_TYPE_MISMATCH_ERR_MSG = "When initializing HasReports::Importer, :resource must be an instance of HasReports::Resource"
+    AUDIT_EXTRA_RECORD_LOG_MSG = "%{option_type} name: %{name}, resource: %{resource} was flagged during an audit. The record may need to be migrated to match a new name or removed as the case may require."
+    AUDIT_EXTRA_EXPANSION_LOG_MSG = "Resource: %{resource}, Expanded Value: \"%{expanded_value}\", Expanded Column: \"%{expanded_column_name}\", Dynamic: \"%{is_dynamic}\", Node: \"%{node}\", was flagged during an audit. The record may need to be migrated to match a new name or removed as the case may require."
+
+    attr_accessor :resource_id, :resource_name
+
+    def initialize(resource_id, resource_name: nil, **_options)
+      @resource_id = resource_id
+      @resource_name = resource_name
+    end
+
+    # def import_select_options(values, resource_id, audit: true, verbose: false)
+    def import_select_options(values, resource_id, verbose: false)
+      values = Array.wrap(values)
+      [].tap do |results|
+        values.each do |attrs|
+          puts "--> SelectOption: #{ attrs.slice(:name, :select_statement).inspect }" if verbose
+          result = build_select_option(attrs, resource_id)
+          results << result
+        rescue => e
+          puts "Error importing SelectOption: #{ attrs.slice(:name, :select_statement).inspect } - #{ e.message }" if verbose
+          results << {
+            success: false,
+            message: "Exception during import: #{e.message}",
+            backtrace: e.backtrace
+          }
+        end
+      end
+    end
+
+    def build_select_option(attrs, resource_id)
+      attrs[:resourceId] = resource_id.to_i if resource_id.present?
+      results = Reports::ExternalGraphqlClient.create_resource(mutation_name: "createHasReportsSelectOption", input_name: "HasReportsSelectOptionInput", attributes: attrs) if attrs.present?
+      create_data = results&.dig("data", "createHasReportsSelectOption")
+      if create_data && create_data["errors"].blank?
+        {
+          success: true,
+          message: "SelectOption created successfully with ID #{create_data["resource"]["id"]}",
+          errors: nil
+        }
+      else
+        errors =
+          if create_data.present?
+            create_data["errors"] || []
+          elsif results&.dig("errors").present?
+            results["errors"].map do |e|
+              {
+                message: e["message"],
+                path: e.dig("extensions", "problems")&.flat_map { |p| p["path"] } || [],
+                explanation: e.dig("extensions", "problems")&.map { |p| p["explanation"] }&.join("; ")
+              }
+            end
+          else
+            []
+          end
+
+        {
+          success: false,
+          message: "Failed to create SelectOption '#{@resource_name}'->'#{attrs[:name]}'",
+          errors: errors
+        }
+      end
+    end
+
+    # def import_filter_options(values, resource_id, audit: true, verbose: false)
+    def import_filter_options(values, resource_id, verbose: false)
+      values = Array.wrap(values)
+      [].tap do |results|
+        values.each do |attrs|
+          puts "--> FilterOption: #{ attrs.slice(:name, :where_statement).inspect }" if verbose
+          result = build_filter_option(attrs, resource_id)
+          results << result
+        rescue => e
+          puts "Error importing FilterOption: #{ attrs.slice(:name, :where_statement).inspect } - #{ e.message }" if verbose
+          results << {
+            success: false,
+            message: "Exception during import: #{e.message}",
+            backtrace: e.backtrace
+          }
+        end
+      end
+    end
+
+    def build_filter_option(attrs, resource_id)
+      attrs[:resourceId] = resource_id.to_i if resource_id.present?
+      results = Reports::ExternalGraphqlClient.create_resource(mutation_name: "createHasReportsFilterOption", input_name: "HasReportsFilterOptionInput", attributes: attrs) if attrs.present?
+      create_data = results&.dig("data", "createHasReportsFilterOption")
+      if create_data && create_data["errors"].blank?
+        {
+          success: true,
+          message: "FilterOption created successfully with ID #{create_data["resource"]["id"]}",
+          errors: nil
+        }
+      else
+        errors =
+          if create_data.present?
+            create_data["errors"] || []
+          elsif results&.dig("errors").present?
+            results["errors"].map do |e|
+              {
+                message: e["message"],
+                path: e.dig("extensions", "problems")&.flat_map { |p| p["path"] } || [],
+                explanation: e.dig("extensions", "problems")&.map { |p| p["explanation"] }&.join("; ")
+              }
+            end
+          else
+            []
+          end
+
+        {
+          success: false,
+          message: "Failed to create FilterOption '#{@resource_name}'->'#{attrs[:name]}'",
+          errors: errors
+        }
+      end
+    end
+  end
+end

data/app/commands/reports/nested_attribute_options.rb

@@ -0,0 +1,134 @@
+# typed: true
+# frozen_string_literal: true
+
+module Reports
+  module NestedAttributeOptions
+    # Generate select options (attributes) for all associations with nested
+    # attributes for the given class.
+    def self.generate_select_options(klass, **_options)
+      [].tap do |results|
+        flattener_klass = ::Flattener.for(klass).pivot_or_self
+        associations = flattener_klass.associations.lazy.select(&:is_nested_attributes?)
+        associations.
+          reject { |association| association.klass.nil? }.
+          reject { |association| association.flattener.class.is_pivot? }.
+          reject { |association| association.merge_into_parent }.
+          select { |association| association.count >= 0 }.
+          each do |association|
+          resource = Flattener::Resource.new(
+            flattener: association.flattener,
+            association: association,
+            parent: Flattener::Resource.new(flattener: Flattener.for(klass).new)
+          )
+          association_root_name = association.name.to_s.singularize
+
+          expansions = Array(association.klass).map do |expand_on|
+            expand_on.respond_to?(:name) ? expand_on.name : expand_on.to_s
+          end
+
+          expansions.each do |_expansion|
+            resource.attributes.each do |attribute|
+              child_column_name = (attribute.column.alias_name || attribute.column_name || attribute.column.name).to_s
+              column_name = [association_root_name, *child_column_name].join("_").underscore
+              column_type = ::Flattener::Column::Types.sql_type_to_type(attribute.column.sql_type)
+              next if column_type == ::Flattener::Column::Types::JSON # skip json
+
+              result = {
+                name: ::Reports::Generator.build_option_name(column_name, preserve_id: true),
+                columnType: column_type.to_s,
+                nestedResourceCount: (association.count if association.count > 0),
+                associationName: association.name.to_s,
+                associationColumnName: column_name,
+              }
+
+              if association.expand_on_column
+                result[:associationColumnName] = [association_root_name, *child_column_name].join("_").underscore
+              end
+
+              if [::Flattener::Column::Types::DATE, ::Flattener::Column::Types::DATETIME].include?(column_type)
+                result[:selectOptionType] = "BelongsTo"
+              end
+
+              results << result
+            end
+          end
+        end
+      end
+    end
+
+    def self.generate_filter_options(klass, **options)
+      [].tap do |results|
+        flattener_klass = ::Flattener.for(klass).pivot_or_self
+        associations = flattener_klass.associations.lazy.
+          select(&:is_nested_attributes?)
+        associations.
+          reject { |association| association.flattener.class.is_pivot? }.
+          reject { |association| association.merge_into_parent }.
+          select { |association| association.count >= 0 }.
+          each do |association|
+          resource = Flattener::Resource.new(
+            flattener: association.flattener,
+            association: association,
+            parent: Flattener::Resource.new(flattener: Flattener.for(klass).new)
+          )
+          association_root_name = association.name.to_s.singularize
+          expansions = Array(association.klass).map do |expand_on|
+            expand_on.respond_to?(:name) ? expand_on.name : expand_on.to_s
+          end
+          expansions.each do |_expansion|
+            resource.attributes.each do |attribute|
+              child_column_name = (attribute.column.alias_name || attribute.column_name || attribute.column.name).to_s
+              column_name = [association_root_name, *child_column_name].join("_").underscore
+              column_type = ::Flattener::Column::Types.sql_type_to_type(attribute.column.sql_type)
+              next if column_type == ::Flattener::Column::Types::JSON # skip json
+              filter_option = ::Reports::FilterOptionGenerator.for(column_type).
+                new(flattener_attr: attribute, attr: column_name, name: ::Reports::Generator.build_option_name(column_name, preserve_id: true), **options).
+                generate.
+                tap do |o|
+                o[:nestedResourceCount] = (association.count if association.count > 0)
+                o[:associationName] = association.name.to_s
+                if [::Flattener::Column::Types::DATE, ::Flattener::Column::Types::DATETIME].include?(column_type)
+                  o.merge!(
+                    filterOptionType: "BelongsTo",
+                    columnType: nil,
+                    operationType: nil,
+                    partialType: nil,
+                  )
+                end
+              end
+
+              results << filter_option
+            end
+          end
+        end
+      end
+    end
+
+    # Check if the attribute is nested (i.e. sales_manager_1_name)
+    def self.is_nested?(attr)
+      is_expanded?(attr.resource)
+    end
+
+    def self.is_expanded?(resource)
+      return false unless resource.try :association
+      resource.association.count > 0 || is_expanded?(resource.parent)
+    end
+
+    def self.expand_on
+      return @expand_on if @expand_on_memoized
+
+      @expand_on_memoized = true
+
+      @expand_on = @expand_on.call if @expand_on.is_a?(Proc)
+
+      # Fallback only if @expand_on was never set
+      if @expand_on.nil? && klass
+        @expand_on = klass.nested_attributes_options.keys
+      end
+
+      @expand_on = Array(@expand_on).map do |expansion|
+        expansion.is_a?(Hash) ? expansion : { value: expansion, column_name: "type" }
+      end
+    end
+  end
+end