has_helpers 5.0.2

data/app/graphql/has_helpers/middleware/application_access.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Middleware
+    module ApplicationAccess
+      # Runs before any GraphQL resource to validate app access and continue if authorized
+      def authorized?(**_args)
+        # NOTE: ideally application_access_control should disable access control, but it's kept like this temporarily for backward compatibility
+        return true if ::Rails.application.config.x.application_access_control.blank?
+
+        return true if self.class.const_defined?(:SKIP_APP_ACCESS_CHECK) && self.class::SKIP_APP_ACCESS_CHECK
+
+        return true unless context[:current_user] && context[:current_application]
+
+        allowed = context[:current_user].
+                  user_organizations.
+                  where(organization_id: context[:current_organization]&.id).
+                  any? { |uo| uo.applications_array.include?(context[:current_application].name) }
+
+        raise GraphQL::ExecutionError, "Unauthorized to access this app" unless allowed
+
+        true
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/mutations/base.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Mutations
+    class Base < ::GraphQL::Schema::Mutation
+      include HasHelpers::Middleware::ApplicationAccess
+
+      private
+
+      def current_application
+        context[:current_application]
+      end
+
+      def current_organization
+        context[:current_organization]
+      end
+
+      def current_user
+        context[:current_user]
+      end
+
+      def request
+        context[:request]
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/mutations/external_data_sync.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Mutations
+    class ExternalDataSync < ::HasHelpers::Mutations::Base
+      field :status, String, null: false
+      field :error,  String, null: true
+
+      argument :resource,     String,                    required: true
+      argument :data,         ::GraphQL::Types::JSON,    required: true
+      argument :is_destroyed, ::GraphQL::Types::Boolean, required: false, default_value: false
+      argument :dependencies, [String],                  required: false, default_value: []
+
+      def resolve(resource:, data:, is_destroyed:, dependencies: [])
+        unless HasHelpers::SyncUtils.dependencies_satisfied?(data, dependencies)
+          return { status: "retry", error: nil }
+        end
+
+        klass = ::ActiveRecord::Base.descendants.find do |model|
+          # In modern Rails, ActiveRecord::Base.descendants can include anonymous or inner classes whose name is nil,
+          # and doing model.name.demodulize will cause it to explode with an undefined method 'demodulize' for nil.
+          model_name = model.name
+          model_name.present? && model_name.demodulize.casecmp?(resource.demodulize)
+        end
+
+        unless klass
+          resource_id = payload_id(data)
+          return {
+            status: "fail",
+            error: "Could not resolve ActiveRecord class for resource=#{resource}, id=#{resource_id}"
+          }
+        end
+
+        record = klass.find_or_initialize_by(id: payload_id(data))
+
+        result = HasHelpers::SyncUtils.apply_mapping(
+          record,
+          data,
+          resource_key: resource.underscore.to_sym,
+          is_destroyed: is_destroyed
+        )
+
+        case result
+        when true
+          HasHelpers::SyncUtils.touch_dependencies!(data, dependencies)
+          { status: "ok", error: nil }
+        when String
+          { status: "fail", error: result }
+        else
+          {
+            status: "fail",
+            error: mapping_result_error(resource: resource, data: data, result: result)
+          }
+        end
+      rescue => e
+        # wrap in GraphQL::ExecutionError so unhandled exceptions return a JSON errors payload
+        # instead of a pink-screen, which the caller GoodJob::SyncDataToApps can't parse.
+        raise GraphQL::ExecutionError, "ExternalDataSync failed for #{resource}: #{e.message}"
+      end
+
+      private
+
+      def mapping_result_error(resource:, data:, result:)
+        "ExternalDataSync apply_mapping returned #{result.inspect} for resource=#{resource}, id=#{payload_id(data)}"
+      end
+
+      def payload_id(data)
+        data["id"] || data[:id]
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/mutations/mark_individual_alert_read.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Mutations
+    class MarkIndividualAlertRead < ::HasHelpers::Mutations::Base
+      field :success, ::GraphQL::Types::Boolean, null: false
+
+      argument :alert_id, ID, required: true
+
+      def resolve(alert_id:)
+        organization = context[:current_organization]
+        return { success: false } unless organization
+
+        alert = ::HasHelpers::NotificationAlert.find_by(
+          id: alert_id,
+          organization_id: organization.id
+        )
+
+        return { success: false } unless alert
+
+        read_status = ::HasHelpers::NotificationAlertStatus::READ
+        alert.update!(status: read_status)
+
+        { success: true }
+      rescue => e
+        Rails.logger.error "Error marking individual alert as read: #{e.message}"
+        { success: false }
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/mutations/mark_notifications_read.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Mutations
+    class MarkNotificationsRead < ::HasHelpers::Mutations::Base
+      field :success, ::GraphQL::Types::Boolean, null: false
+
+      argument :group_title, String, required: false
+      argument :alert_type, String, required: false
+
+      def resolve(group_title: nil, alert_type: nil)
+        organization = context[:current_organization]
+        return { success: false } unless organization
+
+        if alert_type.present?
+          alert_type_record = ::HasHelpers::NotificationAlertType.find_by(name: alert_type)
+          return { success: false } unless alert_type_record
+
+          scope = ::HasHelpers::NotificationAlert.
+            where(organization_id: organization.id).
+            where(alert_type: alert_type_record).
+            joins(:status).
+            where(options: { name: "Unread" })
+
+          Rails.logger.info "Marking all #{alert_type} alerts as read for organization #{organization.id}"
+        elsif group_title.present?
+          scope = ::HasHelpers::NotificationAlert.
+            where(organization_id: organization.id).
+            joins(:status).
+            where(options: { name: "Unread" }).
+            where("payload ->> 'groupTitle' = ?", group_title)
+
+          Rails.logger.info "Marking notifications with groupTitle '#{group_title}' as read for organization #{organization.id}"
+        else
+          return { success: false }
+        end
+
+        read_status = ::HasHelpers::NotificationAlertStatus::READ
+        updated_count = scope.update_all(status_id: read_status.id)
+
+        Rails.logger.info "Successfully marked #{updated_count} notifications as read"
+
+        { success: true }
+      rescue => e
+        Rails.logger.error "Error marking notifications as read: #{e.message}"
+        { success: false }
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/mutations/toggle_favorite.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Mutations
+    class ToggleFavorite < ::HasHelpers::Mutations::Base
+      ::HasHelpers::Favorite.owner_association_reflections.each do |association|
+        foreign_key = association.foreign_key
+        argument foreign_key, ::GraphQL::Types::ID, required: false
+      end
+
+      field :is_favorite, Boolean, null: false
+
+      def resolve(**foreign_keys)
+        has_values = foreign_keys.values.compact.present?
+        return { is_favorite: false } unless has_values
+
+        favorite = ::HasHelpers::Favorite.find_or_initialize_by(
+          created_by_id: current_user.id,
+          organization_id: current_organization.id,
+          **foreign_keys
+        )
+
+        # == Toggle favorite
+        # If favorite exists, delete it
+        # Else create a favorite
+        is_favorite =
+          if favorite.persisted?
+            !favorite.destroy.destroyed?
+          else
+            favorite.save
+          end
+
+        {
+          is_favorite: is_favorite
+        }
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resolvers/app_nav.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+#------------------------------------------------------------------------------
+# Most of the links of the AppNav (navigation sidebar) are hard-coded in react
+# because there's no reason to have to fire off a query to get links that are
+# always going to show for every user. There are some links that are tied to a
+# specific resource like a user or organization though, and those links do
+# require a query. The singleton methods defined in this file are just helper
+# methods that generate these links so that they can be queried using the types
+# defined in the module's nested classes.
+#------------------------------------------------------------------------------
+
+module HasHelpers
+  module Resolvers
+    class AppNav < ::HasHelpers::Resolvers::Base
+      type ::HasHelpers::Types::Layouts::AppNav::Type, null: false
+      description "The navigation sidebar of the app"
+
+      # Creates the link sections in the app nav that are tied to a specific user or organization.
+      def resolve
+        link_sections = []
+
+        # Whether or not an application link section is shown depends on the user.
+        link_section_for_applications = application_link_section(current_application_name: current_application.name, user: current_user)
+        link_sections << link_section_for_applications if link_section_for_applications[:links].any?
+
+        # Whether or not an external links section is shown depends on the organization.
+        external_links = current_organization.organization_links.side_links.select(&:persisted?)
+        parent_links = []
+        children_links = []
+        external_links.each do |el|
+          if el.parent_id.nil?
+            parent_links << el
+          else
+            children_links << el
+          end
+        end
+        link_sections << external_link_section(
+          organization: current_organization,
+          request: request,
+          user: current_user,
+          organization_links: parent_links,
+          sublinks: children_links) if external_links.any?
+
+        { link_sections: link_sections }
+      end
+
+      private
+
+      # The application link section consists of links to other hq applications.
+      def application_link_section(current_application_name:, user:)
+        # new UI login App
+        login_application = ::HasHelpers::Application.find_by(name: "Admin UI")
+        login_application_url = login_application&.try("#{ENV['RAILS_ENV']}_url") || login_application&.production_url
+        # if user has application array
+        application_links = []
+        if defined?(user.applications_array)
+          user_app_names = user.applications_array.reject { |app| app == current_application_name }
+          hq_apps = ::HasHelpers::Application::APPLICATIONS.select { |app| user_app_names.include?(app.name) }
+          application_links = hq_apps.map do |app|
+            if app.name != "Admin UI"
+              { icon_name: "cloud", link_text: app.name, url: "#{login_application_url}/redirect_to?service=#{app.url}", target: "_blank" }
+            else
+              { icon_name: "cloud", link_text: app.name, url: "#{app.url}", target: "_blank" }
+            end
+          end
+        else
+          application_links = []
+        end
+
+        returned_link_section = {
+          heading: "Applications",
+          links: application_links
+        }
+        returned_link_section
+      end
+
+      # The external link section consists of links that are organization-specific.
+      def external_link_section(organization:, request:, user:, organization_links:, sublinks:)
+        links = organization_links.map do |ext_link|
+          {
+            icon_name: ext_link.icon.nil? ? "externalLinkAlt" : "#{ext_link.icon.tr('-', '_').camelize(:lower)}",
+            link_text: ext_link.name,
+            url: ext_link.url,
+            sublinks: sublinks.select { |sublink| sublink.parent_id == ext_link.id }.map do |sublink|
+              { link_text: sublink.name, url: sublink.url }
+            end
+          }
+        end
+
+        # convert "https://agencieshq-preview-223.agencieshq.com" to "https://agencieshq.com"
+        request_base_url = request.base_url.sub(/(#{::HasHelpers::Application::AGENCIESHQ.name.downcase}-preview-(.*?)\.)/, "") if defined?(request.base_url)
+        # Only show Sidekiq and Features links in Agencies.
+        hq_org_ids = [4, 8]
+        if defined?(::HasHelpers::Application::AGENCIESHQ) && (request_base_url == ::HasHelpers::Application::AGENCIESHQ.url) && (hq_org_ids.include?(organization.id) || user.is_support?)
+          org_link_names = organization_links.map(&:name)
+          show_sidekiq = org_link_names.select { |link_name| link_name.downcase.match("sidekiq") }.empty?
+          show_features = org_link_names.select { |link_name| link_name.downcase.match("features") }.empty?
+          links << { icon_name: "bomb", link_text: "Sidekiq", url: "/sidekiq" } if show_sidekiq
+          links << { icon_name: "starHalfO", link_text: "Features", url: "/features" } if show_features
+        end
+
+        { heading: "External Links", links: links }
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resolvers/base.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resolvers
+    class Base < ::GraphQL::Schema::Resolver
+      include HasHelpers::Middleware::ApplicationAccess
+
+      private
+
+      def current_application
+        context[:current_application]
+      end
+
+      def current_organization
+        context[:current_organization]
+      end
+
+      def current_user
+        context[:current_user]
+      end
+
+      def request
+        context[:request]
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resolvers/cards/available_cards.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resolvers
+    module Cards
+      # Resolves the catalog of cards available for a given resource WITHOUT
+      # record data. Global (not scoped to a role): returns card definitions plus
+      # their non-persisted icon hints.
+      # API:
+      #   availableCards(resourceName: String!): [Cards::AvailableCardType!]!
+      class AvailableCards < GraphQL::Schema::Resolver
+        type [::HasHelpers::Types::Cards::AvailableCardType], null: false
+
+        argument :resource_name, String, required: true
+
+        def resolve(resource_name:)
+          app = context[:current_application]
+          raise GraphQL::ExecutionError, "current_application missing from GraphQL context" if app.nil?
+
+          resource = ::HasHelpers::Resource.find_by!(
+            name: resource_name.to_s,
+            application_id: app.id,
+            parent_id: nil
+          )
+
+          ::HasHelpers::Cards::AvailableCardsCommand.call(resource_id: resource)
+        end
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resolvers/cards/card_data.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resolvers
+    module Cards
+      # Resolves all cards (definitions and data) for a given role/resource_name/record_id.
+      # API:
+      #   cardData(
+      #     roleId: ID,
+      #     resourceName: String!,
+      #     recordId: ID!
+      #   ): [Cards::CardDataType!]!
+      # For each CardDefinition linked to the given resource, this resolver
+      # calls HasHelpers::Cards::CardDataCommand and returns an array of card payloads.
+      class CardData < GraphQL::Schema::Resolver
+        # We return a list of CardDataType, one per card/identifier.
+        type [::HasHelpers::Types::Cards::CardDataType], null: false
+
+        argument :role_id,       ID,     required: false
+        argument :resource_name, String, required: true
+        argument :record_id,     ID,     required: true
+
+        def resolve(role_id: nil, resource_name:, record_id:)
+          app = context[:current_application]
+          raise GraphQL::ExecutionError, "current_application missing from GraphQL context" if app.nil?
+
+          resource = ::HasHelpers::Resource.find_by!(
+            name: resource_name.to_s,
+            application_id: app.id,
+            parent_id: nil
+          )
+
+          # Load the main record once; it will be reused for all cards
+          record = resource.klass.find(record_id)
+
+          # Load all card_definitions for this resource and eager-load
+          # the associations needed by the command to avoid N+1.
+          card_definitions =
+            ::HasHelpers::Cards::CardDefinition.
+              joins(:card_definition_resources).
+              where(card_definition_resources: { resource_id: resource.id }).
+              ordered.
+              includes(
+                :identifier,
+                :layout_type,
+                :variant,
+                card_fields: %i[field_resource data_type],
+                role_resource_cards: [:role_card_fields],
+                card_definition_resources: { resource: :application }
+              ).
+              distinct
+
+          card_definitions.map do |card_definition|
+            result = ::HasHelpers::Cards::CardDataCommand.call_with_record(
+              role_id: role_id,
+              # We pass the Resource and Identifier objects directly. The command
+              # supports both ids and instances via find_resource/find_identifier.
+              resource_id: resource,
+              identifier_id: card_definition.identifier,
+              record: record
+            )
+
+            {
+              application: app.name,
+              card: result.card,
+              fields: result.fields,
+              entries: result.entries
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/app/graphql/has_helpers/resolvers/cards/hover_card_data.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module HasHelpers
+  module Resolvers
+    module Cards
+      class HoverCardData < GraphQL::Schema::Resolver
+        type ::HasHelpers::Types::Cards::CardDataType, null: true
+
+        argument :role_id,       ID,     required: false
+        argument :resource_name, String, required: true
+        argument :record_id,     ID,     required: true
+        argument :identifier,    String, required: true
+
+        # Hover-only cards are not persisted. We assemble an in-memory
+        # CardDefinition (and its CardField rows) from the DSL registry and
+        # hand it off to CardDataCommand via the dedicated entry point.
+        def resolve(resource_name:, record_id:, identifier:, role_id: nil)
+          _ = role_id
+          app = context[:current_application]
+          raise GraphQL::ExecutionError, "current_application missing from GraphQL context" if app.nil?
+
+          resource = ::HasHelpers::Resource.find_by!(
+            name: resource_name.to_s,
+            application_id: app.id,
+            parent_id: nil
+          )
+
+          registry_card = find_registry_card(identifier)
+          return nil unless registry_card
+
+          card_definition = build_virtual_card_definition(registry_card, resource)
+          return nil unless card_definition
+
+          record = resource.klass.find(record_id)
+          result = ::HasHelpers::Cards::CardDataCommand.call_with_definition(
+            resource_id:     resource,
+            card_definition: card_definition,
+            record:          record
+          )
+
+          {
+            application: app.name,
+            card:        result.card,
+            fields:      result.fields,
+            entries:     result.entries
+          }
+        end
+
+        private
+
+        def find_registry_card(identifier_name)
+          key = identifier_name.to_s
+          ::HasHelpers::Cards::Registry.cards.find do |c|
+            id = c[:identifier]
+            id_str = id.respond_to?(:name) && !id.is_a?(String) ? id.name.to_s : id.to_s
+            id_str == key && c[:hover_only]
+          end
+        end
+
+        def build_virtual_card_definition(registry_card, resource)
+          # Hover-only cards are not persisted, so the identifier is an in-memory CardIdentifier
+          # instance (never saved). We don't look up the DB-backed option row.
+          identifier_string = normalize_identifier(registry_card[:identifier])
+          identifier_stub   = ::HasHelpers::Cards::CardIdentifier.new(name: identifier_string)
+          layout_option     = enum_for(::HasHelpers::Cards::CardLayoutType, registry_card[:layout_type] || registry_card[:layout])
+          variant_option    = registry_card[:variant] && enum_for(::HasHelpers::Cards::CardVariantType, registry_card[:variant])
+
+          definition = ::HasHelpers::Cards::CardDefinition.new(
+            name:               registry_card[:name].to_s,
+            identifier:         identifier_stub,
+            layout_type:        layout_option,
+            variant:            variant_option,
+            description:        registry_card[:description].to_s,
+            is_customizable:    false,
+            position:           registry_card[:default_position],
+            default_visibility: true
+          )
+          definition.id = Digest::UUID.uuid_v5(
+            Digest::UUID::OID_NAMESPACE,
+            "hover-card:#{normalize_identifier(registry_card[:identifier])}"
+          )
+          definition.relationship       = registry_card[:relationship].to_s if registry_card[:relationship]
+          definition.relationship_klass = registry_card[:relationship_klass].to_s if registry_card[:relationship_klass]
+
+          Array(registry_card[:fields]).each_with_index do |raw_field, index|
+            field = raw_field.deep_symbolize_keys
+            card_field = build_virtual_card_field(field, registry_card, index, resource)
+            definition.card_fields << card_field if card_field
+          end
+
+          definition
+        end
+
+        def build_virtual_card_field(field, registry_card, index, _resource)
+          kind = field[:kind]&.to_sym
+          data_type_option = enum_for(::HasHelpers::Cards::CardDataType, field[:data_type])
+          return nil unless data_type_option
+
+          # UUID column on card_fields — generate a deterministic UUID5 from a stable string.
+          deterministic_id = Digest::UUID.uuid_v5(
+            Digest::UUID::OID_NAMESPACE,
+            "hover:#{normalize_identifier(registry_card[:identifier])}:#{kind}:#{field[:ref] || field[:key] || index}"
+          )
+
+          card_field = ::HasHelpers::Cards::CardField.new(
+            data_type:          data_type_option,
+            is_required:        !!field[:is_required],
+            default_position:   field[:default_position] || ((index + 1) * 10),
+            default_visibility: field[:default_visibility].nil? ? true : !!field[:default_visibility]
+          )
+          card_field.id = deterministic_id
+
+          case kind
+          when :resource
+            # In-memory stand-in: CardDataCommand only reads `.name` and `.alias_name` off field_resource.
+            stub = ::HasHelpers::Resource.new(name: field[:ref].to_s)
+            stub.alias_name = field[:name].to_s if field[:name].present? && stub.respond_to?(:alias_name=)
+            card_field.field_resource = stub
+          when :virtual
+            card_field.virtual_ref = field[:ref].to_s if card_field.respond_to?(:virtual_ref=)
+          when :custom
+            card_field.field_custom_name = field[:name].to_s if card_field.respond_to?(:field_custom_name=)
+          end
+
+          card_field.custom_label     = !!field[:custom_label] if card_field.respond_to?(:custom_label=)
+          card_field.custom_label_key = field[:custom_label_key].to_s if field[:custom_label_key] && card_field.respond_to?(:custom_label_key=)
+
+          card_field
+        end
+
+        def enum_for(klass, value)
+          return nil if value.nil?
+          name =
+            case value
+            when Symbol then value.to_s.camelize
+            when String then value.camelize
+            else
+              value.respond_to?(:name) ? value.name.to_s : value.to_s.camelize
+            end
+          klass.find_by(name: name)
+        end
+
+        def normalize_identifier(identifier_value)
+          if identifier_value.respond_to?(:name) && !identifier_value.is_a?(String)
+            identifier_value.name.to_s
+          else
+            identifier_value.to_s
+          end
+        end
+      end
+    end
+  end
+end