protege 0.1.0.alpha.1

data/app/helpers/protege/components/menus_helper.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Protege
+  module Components
+    # The +<details>+-based dropdown menu: +dropdown_menu+ renders the trigger + panel (with a backdrop
+    # that closes it), and +dropdown_item+ renders each entry as a link or form button, with an +active+
+    # variant for filter-style menus.
+    module MenusHelper
+      # Render a +<details>+-based dropdown menu with a backdrop that closes it.
+      #
+      # @param label [String] the trigger text (defaults to a kebab +···+)
+      # @yield the menu items, rendered inside the dropdown panel
+      # @return [ActiveSupport::SafeBuffer] the dropdown markup
+      def dropdown_menu(label: '···', &block)
+        tag.details(class: 'relative') do
+          tag.summary(label, class: 'cursor-pointer list-none text-base font-bold select-none',
+                             style: 'color: var(--text-faint)') +
+            tag.div(class: 'fixed inset-0 z-10', onclick: "this.closest('details').removeAttribute('open')") +
+            tag.div(class: 'absolute right-0 mt-1 w-36 rounded-lg py-1 shadow-lg z-20',
+                    style: 'background: var(--surface); border: 1px solid var(--border)') { capture(&block) }
+        end
+      end
+
+      # Render a single dropdown entry, either a link or a form button. Pass +active: true+ to mark the
+      # current selection — the entry is emphasized and gets a trailing check (for filter-style menus).
+      #
+      # @param text [String] the entry label
+      # @param href [String] the entry target
+      # @param method [Symbol, nil] when set, render a form button using this verb
+      # @param active [Boolean] whether this entry is the current selection
+      # @param destructive [Boolean] whether to apply destructive (red) styling
+      # @return [ActiveSupport::SafeBuffer] the entry markup
+      def dropdown_item(text, href, method: nil, active: false, destructive: false)
+        text_class = destructive ? 'text-red-500 hover:text-red-700' : ''
+        weight     = active ? 'font-semibold' : ''
+        base_class = 'flex w-full items-center justify-between gap-2 text-left text-sm px-3 py-1.5 ' \
+                     "cursor-pointer #{text_class} #{weight}".squish
+        content    = active ? safe_join([text, tag.span('✓', style: 'color: var(--color-amber-500, #f59e0b)')]) : text
+
+        if method
+          button_to content, href,
+                    method:,
+                    class:  "#{base_class} bg-transparent border-0",
+                    form:   { class: 'w-full' }
+        else
+          link_to content, href, class: base_class
+        end
+      end
+
+      # Render a navigation link, highlighted when the current path is under it.
+      #
+      # @param text [String] the link text
+      # @param href [String] the link target
+      # @param current_path [String] the request path used to compute the active state
+      # @return [ActiveSupport::SafeBuffer] the nav-item markup
+      def nav_item(text, href, current_path)
+        active  = current_path.start_with?(href)
+        classes = 'rounded-sm px-2.5 py-1 text-xs font-medium transition-colors'
+        style   = if active
+                    'background: var(--surface-subtle); color: var(--text)'
+                  else
+                    'color: var(--text-muted)'
+                  end
+        link_to(text, href, class: classes, style:)
+      end
+    end
+  end
+end

data/app/helpers/protege/components/pagination_helper.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Protege
+  module Components
+    # Pagination for sidebar lists: +paginate+ slices a relation into a page of records plus the page
+    # metadata, and +sidebar_pagination+ renders that metadata as the sidebar's bottom bar — a prev
+    # arrow, the first/current/last page numbers, and a next arrow.
+    #
+    # Pagy supplies only the page math (count + page → offset/limit and the prev/next/last numbers); the
+    # markup is ours so it matches the sidebar styling. Colors use the same CSS custom properties as the
+    # rest of the layout (--text, --text-muted, --text-faint, --border) so dark mode follows along.
+    module PaginationHelper
+      # Paginate a relation for a sidebar list, returning the page metadata and the page of records.
+      #
+      # Wraps Pagy's standalone object (no +Pagy::Backend+ controller mixin needed): it counts the scope,
+      # resolves the requested page, and slices the relation with +offset+/+limit+. The page defaults to
+      # the +?page=+ query param; a +nil+ or non-numeric value falls back to page 1, and an overflowing
+      # one is clamped to the last page (the +:last_page+ overflow default set at boot).
+      #
+      # @param scope [ActiveRecord::Relation] the relation to page through
+      # @param page [String, Integer, nil] the requested page (defaults to +params[:page]+)
+      # @param limit [Integer] the page size
+      # @return [Array(Pagy, ActiveRecord::Relation)] the pagy metadata and the page of records
+      def paginate(scope, page: params[:page], limit: 15)
+        pagy = ::Pagy.new(count: scope.count, page: [page.to_i, 1].max, limit:)
+        [pagy, scope.offset(pagy.offset).limit(pagy.limit)]
+      end
+
+      # Render the sidebar's bottom pagination bar from a Pagy object — a prev arrow, the
+      # first/current/last page numbers, and a next arrow. Mirrors +sidebar_header+ (same bar shape, a
+      # top border) but pinned to the bottom of the sidebar. Renders nothing for a single page, so a
+      # sidebar can render it unconditionally and it only appears once the list outgrows one page.
+      #
+      # Links target the current path with a merged +:page+, so paging the sidebar keeps the main view
+      # (e.g. an open thread) in place and re-pages only the list.
+      #
+      # @param pagy [Pagy] the page metadata for the sidebar's collection
+      # @return [ActiveSupport::SafeBuffer] the footer markup, or an empty buffer for a single page
+      def sidebar_pagination(pagy)
+        return ''.html_safe if pagy.pages <= 1
+
+        tag.div(class: 'flex h-10 flex-shrink-0 items-center justify-between px-4 text-xs',
+                style: 'border-top: 1px solid var(--border)') do
+          [
+            sidebar_page_arrow('◀︎', pagy.prev),
+            sidebar_page_numbers(pagy),
+            sidebar_page_arrow('▶︎', pagy.next)
+          ].join.html_safe
+        end
+      end
+
+      private
+
+      # Render a pagination arrow — a link to +page+, or a faint inert span at the first/last boundary
+      # (when +page+ is +nil+).
+      #
+      # @param glyph [String] the arrow character
+      # @param page [Integer, nil] the target page, or nil to disable the arrow
+      # @return [ActiveSupport::SafeBuffer] the arrow markup
+      def sidebar_page_arrow(glyph, page)
+        classes = 'px-1'
+        return tag.span(glyph, class: classes, style: 'color: var(--text-faint)') unless page
+
+        link_to(glyph, sidebar_page_url(page), class: "#{classes} text-amber-600 hover:text-amber-700")
+      end
+
+      # Render the middle page numbers — the distinct first/current/last pages in order, dot-separated,
+      # with the current page emphasized and the others linked.
+      #
+      # @param pagy [Pagy] the page metadata
+      # @return [ActiveSupport::SafeBuffer] the page-number markup
+      def sidebar_page_numbers(pagy)
+        pages     = [1, pagy.page, pagy.last].uniq.sort
+        separator = tag.span('·', class: 'px-1', style: 'color: var(--text-faint)')
+
+        safe_join(pages.map { |n| sidebar_page_number(n, current: n == pagy.page) }, separator)
+      end
+
+      # Render a single middle page number — an emphasized span for the current page, a link otherwise.
+      #
+      # @param page [Integer] the page number
+      # @param current [Boolean] whether this is the current page
+      # @return [ActiveSupport::SafeBuffer] the page-number markup
+      def sidebar_page_number(page, current:)
+        return tag.span(page, class: 'font-semibold', style: 'color: var(--text)') if current
+
+        ui_link(page.to_s, sidebar_page_url(page))
+      end
+
+      # Build the URL for a sidebar page — the current path with +:page+ merged into its query, so the
+      # main view stays put while the sidebar re-pages.
+      #
+      # @param page [Integer] the target page
+      # @return [String] the path with the merged page param
+      def sidebar_page_url(page)
+        "#{request.path}?#{request.query_parameters.merge('page' => page).to_query}"
+      end
+    end
+  end
+end

data/app/helpers/protege/components/sidebar_helper.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Protege
+  module Components
+    # The console sidebar surface — the docked +<aside>+ shell and the header/list/footer elements that
+    # fill it. Split out of +LayoutHelper+ so the sidebar is a single focused concern: +sidebar_container+
+    # is the resizable outer shell, +sidebar_content+ the flex column inside it, and +sidebar_header+ /
+    # +sidebar_search_link+ / +sidebar_body+ / +sidebar_item+ / +sidebar_stream+ compose the list.
+    #
+    # Colors use the CSS custom properties (--surface, --border, --text, --text-muted, --text-faint)
+    # defined in tailwind/application.css so dark mode works via a single .dark class toggle.
+    module SidebarHelper
+      # Render the sidebar shell — the resizable, full-height +<aside>+ that docks the navigation sidebar
+      # on the left of the console. The user can drag its right edge to resize it (the general
+      # +resize_handle+ paired with +resize.js+), bounded by min/max and remembered across page loads. The
+      # yielded block is the sidebar's content (typically a +sidebar_content+ wrapper).
+      #
+      # @yield the sidebar contents
+      # @return [ActiveSupport::SafeBuffer] the aside markup
+      def sidebar_container(&block)
+        tag.aside(class: 'relative flex w-72 flex-shrink-0 flex-col overflow-hidden',
+                  data:  { resize: '', resize_edge: 'right', resize_min: 200,
+                           resize_max: 480, resize_key: 'protege:sidebar-width' }) do
+          resize_handle(edge: :right) + capture(&block)
+        end
+      end
+
+      # Wrap a sidebar's contents (header, scrollable list, pagination footer) in the flex column that
+      # fills the sidebar shell — header/footer stay fixed while the list scrolls between them.
+      #
+      # Pass +frame:+ to render the column as a Turbo Frame (an update target a form/stream can replace)
+      # instead of a plain div; the same layout classes apply either way. A bare +<turbo-frame>+ is
+      # +display: inline+, so the classes (which set it +flex+) are what make the frame variant lay out at all.
+      #
+      # @param frame [String, nil] a Turbo Frame id to render as, or nil for a plain div
+      # @yield the sidebar contents
+      # @return [ActiveSupport::SafeBuffer] the column markup
+      def sidebar_content(frame: nil, &)
+        classes = 'flex min-h-0 flex-1 flex-col'
+        frame ? turbo_frame_tag(frame, class: classes, &) : tag.div(class: classes, &)
+      end
+
+      # Render the scrollable list area of a sidebar — the flexible middle that grows between the fixed
+      # header and pagination footer.
+      #
+      # Two forms:
+      # * +sidebar_body(collection, empty: '…') { |item| … }+ renders each item via the block, or a muted
+      #   empty-state hint when the collection is empty — the common list sidebar.
+      # * +sidebar_body { … }+ (no collection) just wraps arbitrary content, for sidebars that own their
+      #   own iteration/empty handling (e.g. the Inbox's Turbo Frame, the search results' two empty states).
+      #
+      # @param collection [Enumerable, nil] the items to render, or nil for the block-only form
+      # @param empty [String, nil] the empty-state message for the collection form
+      # @param id [String, nil] DOM id for the scroll container — the live-append broadcast target
+      # @yield [item] each item (collection form), or the raw body (block-only form)
+      # @return [ActiveSupport::SafeBuffer] the scrollable body markup
+      def sidebar_body(collection = nil, empty: nil, id: nil, &block)
+        tag.div(class: 'flex-1 overflow-y-auto', id:) do
+          if collection.nil?
+            capture(&block)
+          elsif collection.any?
+            safe_join(collection.map { |item| capture(item, &block) })
+          else
+            hint(empty, classes: 'py-8 text-center')
+          end
+        end
+      end
+
+      # Subscribe the sidebar to a Turbo Stream for live-appended rows — but only on the first page.
+      #
+      # New rows are broadcast (prepend/append) into +sidebar_body+'s +id+ target; gating the
+      # *subscription* to page 1 is how we keep live rows from landing on the wrong page — later pages
+      # simply aren't subscribed and reconcile on their next load. Row-replace updates are id-targeted,
+      # so they're unaffected by whether this subscription is present.
+      #
+      # @param streamables [Array] the Turbo stream identifier(s) (e.g. a string, or +[record, :scope]+)
+      # @param pagy [Pagy] the list's pagination — the subscription renders only when +pagy.page == 1+
+      # @return [ActiveSupport::SafeBuffer] the stream-source tag on page 1, else an empty buffer
+      def sidebar_stream(*streamables, pagy:)
+        return ''.html_safe unless pagy.page == 1
+
+        turbo_stream_from(*streamables)
+      end
+
+      # Render a fixed-height sidebar bar — the standard horizontal strip (bordered, faint, padded) used
+      # for a labeled control row such as the trace filter. Its contents are yielded and laid out with
+      # space-between, matching the +sidebar_header+/+sidebar_search_link+ bar shape.
+      #
+      # @yield the bar contents (typically a label span and a control)
+      # @return [ActiveSupport::SafeBuffer] the bar markup
+      def sidebar_bar(&)
+        tag.div(class: 'flex h-10 flex-shrink-0 items-center justify-between px-4 text-xs',
+                style: 'border-bottom: 1px solid var(--border); color: var(--text-faint)', &)
+      end
+
+      # Render a sidebar section header with an optional "new record" link.
+      #
+      # @param title [String] the section title
+      # @param new_path [String, nil] optional target for the new-record link
+      # @param new_label [String] the new-record link label
+      # @return [ActiveSupport::SafeBuffer] the sidebar header markup
+      def sidebar_header(title, new_path: nil, new_label: 'New')
+        tag.div(class: 'flex h-10 flex-shrink-0 items-center justify-between px-4',
+                style: 'border-bottom: 1px solid var(--border)') do
+          tag.span(title, class: 'text-xs font-semibold uppercase tracking-wider', style: 'color: var(--text-faint)') +
+            (new_path ? ui_link(new_label, new_path) : ''.html_safe)
+        end
+      end
+
+      # Render a sidebar search affordance — a faux search field that links to a search page.
+      #
+      # Styled like an input (magnifier + muted placeholder) but it is a plain link: clicking it
+      # navigates to +href+. Sits between the sidebar header and its list.
+      #
+      # @param href [String] the search page to open
+      # @param placeholder [String] the muted prompt text
+      # @return [ActiveSupport::SafeBuffer] the search-bar markup
+      def sidebar_search_link(href, placeholder: 'Search…')
+        classes = 'flex h-10 flex-shrink-0 items-center gap-2 px-4 text-xs transition-colors hover:opacity-80'
+        link_to(href, class: classes, style: 'border-bottom: 1px solid var(--border); color: var(--text-faint)') do
+          search_icon + tag.span(placeholder)
+        end
+      end
+
+      # Render a sidebar list entry — title, optional detail/subtitle, and an
+      # optional extra block — highlighted when +active+.
+      #
+      # @param title [String] the entry title
+      # @param href [String] the entry target
+      # @param detail [String, ActiveSupport::SafeBuffer, nil] right-aligned detail text or markup
+      # @param subtitle [String, nil] optional subtitle line
+      # @param active [Boolean] whether to highlight the entry as current
+      # @param attrs [Hash] extra HTML attributes forwarded to the link
+      # @yield optional extra content rendered beneath the subtitle
+      # @return [ActiveSupport::SafeBuffer] the sidebar entry markup
+      def sidebar_item(title, href, detail: nil, subtitle: nil, active: false, **attrs, &block)
+        link_to(href, class: 'block px-4 py-3 transition-colors', style: sidebar_item_style(active), **attrs) do
+          sidebar_item_header(title, detail) +
+            sidebar_item_subtitle(subtitle) +
+            (block ? tag.div(class: 'mt-1', &block) : ''.html_safe)
+        end
+      end
+
+      private
+
+      # The magnifier glyph for +sidebar_search_link+ — a small inline SVG (not an emoji) that inherits
+      # the link's color via +currentColor+, so it tracks the theme.
+      #
+      # @return [ActiveSupport::SafeBuffer] the inline SVG markup
+      def search_icon
+        raw <<~SVG
+          <svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="flex-shrink-0">
+            <circle cx="11" cy="11" r="7"></circle>
+            <line x1="21" y1="21" x2="16.65" y2="16.65"></line>
+          </svg>
+        SVG
+      end
+
+      # ── Sidebar item helpers ─────────────────────────────────────
+
+      # Build the inline style for a sidebar entry, highlighting it when active.
+      #
+      # @param active [Boolean] whether the entry is the current one
+      # @return [String] the entry's CSS style string
+      def sidebar_item_style(active)
+        if active
+          'background: var(--surface-subtle); border-left: 2px solid var(--color-amber-500, #f59e0b)'
+        else
+          'border-left: 2px solid transparent'
+        end
+      end
+
+      # Render a sidebar entry's title row with its right-aligned detail.
+      #
+      # A String detail is wrapped in a muted span; any other truthy value is
+      # rendered as-is (e.g. prebuilt markup), and nil renders nothing.
+      #
+      # @param title [String] the entry title
+      # @param detail [String, ActiveSupport::SafeBuffer, nil] the detail text or markup
+      # @return [ActiveSupport::SafeBuffer] the title row markup
+      def sidebar_item_header(title, detail)
+        tag.div(class: 'flex items-baseline justify-between gap-2') do
+          tag.span(title, class: 'truncate text-xs font-semibold') + sidebar_item_detail(detail)
+        end
+      end
+
+      # Render a sidebar entry's detail value.
+      #
+      # @param detail [String, ActiveSupport::SafeBuffer, nil] the detail text or markup
+      # @return [ActiveSupport::SafeBuffer] the detail markup, or an empty buffer
+      def sidebar_item_detail(detail)
+        if detail.is_a?(String)
+          return tag.span(detail, class: 'flex-shrink-0 text-xs',
+                                  style: 'color: var(--text-faint)')
+        end
+
+        detail || ''.html_safe
+      end
+
+      # Render a sidebar entry's subtitle line, or nothing.
+      #
+      # @param subtitle [String, nil] the subtitle text
+      # @return [ActiveSupport::SafeBuffer] the subtitle markup, or an empty buffer
+      def sidebar_item_subtitle(subtitle)
+        return ''.html_safe unless subtitle
+
+        tag.p(subtitle, class: 'mt-0.5 truncate text-xs', style: 'color: var(--text-muted)')
+      end
+    end
+  end
+end

data/app/helpers/protege/components/tables_helper.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Protege
+  module Components
+    # The simple data-table component: a header list + rows in, table markup out, with a built-in empty
+    # state so call sites never need their own empty-vs-populated branch. Theme colors come from CSS
+    # custom properties so the table tracks light/dark mode.
+    module TablesHelper
+      # A table's data model: column +headers+ and +rows+ (each row an array of cells). Built by view
+      # helpers and passed straight to +#table+, so a caller defines both halves in one place.
+      Table = Struct.new(:headers, :rows, keyword_init: true)
+
+      # Render a simple data table from a header list and a list of rows.
+      #
+      # Each row is an array of cell values, positionally aligned to +headers+; cell values may be plain
+      # strings or already-rendered markup (e.g. a +badge+ or +destructive_link+), which is emitted as-is.
+      # Theme colors come from CSS custom properties so the table tracks light/dark mode.
+      #
+      # When +rows+ is empty the table renders a centered, muted +empty+ message in place of the body, so
+      # call sites never need their own empty-vs-populated branch.
+      #
+      # @example
+      #   table(headers: ["Kind", "Pattern", ""], rows: rules.map { |r| [badge(r.kind), r.pattern, remove_link(r)] })
+      #
+      # @param headers [Array<String>] the column headers (use +""+ for an unlabeled column)
+      # @param rows [Array<Array>] the rows, each an array of cells aligned to +headers+
+      # @param empty [String] the message shown, centered, when there are no rows
+      # @return [ActiveSupport::SafeBuffer] the table markup
+      def table(headers:, rows:, empty: 'No results.')
+        return tag.p(empty, class: 'text-center text-sm py-6', style: 'color: var(--text-faint)') if rows.empty?
+
+        tag.table(class: 'w-full text-sm') do
+          tag.thead do
+            tag.tr do
+              safe_join(headers.map do |header|
+                tag.th(header, class: 'text-left font-medium pb-2 pr-4', style: 'color: var(--text-faint)')
+              end)
+            end
+          end +
+            tag.tbody do
+              safe_join(rows.map { |cells| table_row(cells) })
+            end
+        end
+      end
+
+      private
+
+      # Render one +table+ body row from its cells, divided from the row above by a top border.
+      #
+      # @param cells [Array] the row's cell values, emitted in order
+      # @return [ActiveSupport::SafeBuffer] the +<tr>+ markup
+      def table_row(cells)
+        tag.tr(style: 'border-top: 1px solid var(--border)') do
+          safe_join(cells.map { |cell| tag.td(cell, class: 'py-3 pr-4 align-middle') })
+        end
+      end
+    end
+  end
+end

data/app/helpers/protege/components/typography_helper.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Protege
+  module Components
+    # Text primitives: headings, muted hints, and verbatim/monospace blocks. Theme colors come from CSS
+    # custom properties (--text-faint, …) so type tracks light/dark mode via the single +.dark+ toggle.
+    module TypographyHelper
+      # Render a level-1 heading.
+      #
+      # @param text [String] the heading text
+      # @return [ActiveSupport::SafeBuffer] the +<h1>+ markup
+      def heading_1(text)
+        tag.h1(text, class: 'text-lg font-semibold')
+      end
+
+      # Render a level-2 heading styled as a muted, uppercase section label.
+      #
+      # @param text [String] the heading text
+      # @return [ActiveSupport::SafeBuffer] the +<h2>+ markup
+      def heading_2(text)
+        tag.h2(text, class: 'text-xs font-semibold uppercase tracking-wider', style: 'color: var(--text-faint)')
+      end
+
+      # Render a level-3 heading.
+      #
+      # @param text [String] the heading text
+      # @return [ActiveSupport::SafeBuffer] the +<h3>+ markup
+      def heading_3(text)
+        tag.h3(text, class: 'text-sm font-semibold')
+      end
+
+      # Render a line of muted helper text — a caption, hint, or inline empty-state note.
+      #
+      # @param text [String] the hint text
+      # @return [ActiveSupport::SafeBuffer] the muted paragraph markup
+      # @param [String] classes
+      def hint(text, classes: '')
+        tag.p(text, class: "text-xs #{classes}", style: 'color: var(--text-faint)')
+      end
+
+      # Render a block of verbatim body text — whitespace preserved, monospace — for content shown
+      # as-is, such as an email body or a persona's instructions. Escapes its input.
+      #
+      # @param text [String] the text to render
+      # @return [ActiveSupport::SafeBuffer] the preformatted text block
+      def body_text(text)
+        tag.div(text, class: 'text-sm whitespace-pre-wrap font-mono')
+      end
+
+      # Render a short code snippet as a boxed, monospace chip — a config line or command shown inline in
+      # a page (e.g. an empty state). Sizes to its content, matching the +badge+ surface/border styling.
+      # Click-to-copy: the +data-copy+ marker wires it to copy.js (copies the text on click) and the
+      # matching CSS rule shows the copy cursor on hover. Escapes its input.
+      #
+      # @param text [String] the code to display
+      # @return [ActiveSupport::SafeBuffer] the code-chip markup
+      def code_block(text)
+        tag.code(text, class: 'inline-block rounded-md px-3 py-1.5 text-xs font-mono break-all',
+                       data:  { copy: true },
+                       style: 'background: var(--surface-subtle); border: 1px solid var(--border)')
+      end
+    end
+  end
+end

data/app/helpers/protege/email_domains_helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Protege
+  # View helpers for email-domain pages and the domains sidebar.
+  module EmailDomainsHelper
+    # Fetch every +EmailDomain+ ordered by name for sidebar listing.
+    #
+    # @return [ActiveRecord::Relation<Protege::EmailDomain>] domains ordered alphabetically
+    def all_email_domains
+      EmailDomain.order(:domain)
+    end
+
+    # Whether Protege is running the self-hosted MTA (as opposed to an email provider). Keys off the
+    # existing accessory setting via +Gateway.mail_accessory_host+ — no separate flag. Drives the
+    # mode-aware domain page: only self-hosting uses +EmailDomain+'s own DKIM key and can push to an MTA.
+    #
+    # @return [Boolean] true when a mail accessory is configured
+    def mail_self_hosted?
+      Gateway.mail_accessory_host.present?
+    end
+  end
+end