postnhost 0.0.0 → 0.1.1

data/app/models/postnhost/setting.rb

@@ -0,0 +1,116 @@
+require "uri"
+
+module Postnhost
+  class Setting < ApplicationRecord
+    include Postnhost::SchemaLocalizable
+    include Postnhost::PublicRevisionTouch
+
+    self.table_name = "postnhost_settings"
+
+    PUBLIC_PAGE_SIZE_RANGE = Postnhost::Configuration::PUBLIC_PAGE_SIZE_RANGE
+    SITE_INDEXING_OPTIONS = %w[index noindex].freeze
+    TIMEZONE_NAMES = ActiveSupport::TimeZone.all.map { |zone| zone.tzinfo.name }.uniq.freeze
+    mount_uploader :site_logo, Postnhost::SettingAssetUploader
+    mount_uploader :og_image, Postnhost::SettingAssetUploader
+
+    has_one :navigation, class_name: "Postnhost::Navigation", dependent: :destroy, inverse_of: :setting
+    has_many :site_scripts, class_name: "Postnhost::SiteScript", dependent: :destroy, inverse_of: :setting
+
+    validates :timezone, inclusion: { in: TIMEZONE_NAMES }, allow_blank: true
+    validates :site_indexing, inclusion: { in: SITE_INDEXING_OPTIONS }
+    validates :public_page_size, numericality: { only_integer: true, in: PUBLIC_PAGE_SIZE_RANGE }, allow_nil: true
+    validates :use_auto_header_navigation, inclusion: { in: [true, false] }
+    validates :use_auto_footer_navigation, inclusion: { in: [true, false] }
+    validates :author_pages_enabled, inclusion: { in: [true, false] }
+    validates :search_enabled, inclusion: { in: [true, false] }
+    validates :show_powered_by, inclusion: { in: [true, false] }
+    validate :site_url_is_http_origin
+
+    before_validation :normalize_site_url
+    before_validation :normalize_timezone
+    after_commit :clear_i18n_cache, if: :saved_change_to_locale_overrides?
+
+    def self.current
+      first_or_create!
+    end
+
+    def self.effective_timezone_name
+      current.effective_timezone_name
+    end
+
+    def effective_timezone_name
+      selected_timezone = timezone.presence || Postnhost.config.default_timezone
+      ActiveSupport::TimeZone[selected_timezone]&.name || "UTC"
+    end
+
+    def effective_site_url
+      site_url.presence || Postnhost.config.site_url
+    end
+
+    def effective_public_page_size
+      public_page_size || Postnhost.config.public_page_size
+    end
+
+    def site_url_options
+      return {} if effective_site_url.blank?
+
+      uri = URI.parse(effective_site_url)
+      { host: uri.host, protocol: uri.scheme, port: uri.port }
+    end
+
+    def canonical_url_for(url)
+      uri = URI.parse(url)
+      if effective_site_url.blank?
+        uri.query = nil
+        uri.fragment = nil
+        return uri.to_s
+      end
+
+      path = uri.path.presence || "/"
+      "#{effective_site_url}#{path}"
+    end
+
+    def site_configuration_cache_key
+      [effective_site_url, effective_public_page_size, site_indexing]
+    end
+
+    def schema_settings_hash
+      schema_settings.is_a?(Hash) ? schema_settings.deep_stringify_keys : {}
+    end
+
+    def schema_setting(key, default: nil)
+      schema_settings_hash[key.to_s].presence || default
+    end
+
+    def current_navigation
+      navigation || create_navigation!
+    end
+
+    private
+
+    def normalize_site_url
+      self.site_url = site_url.to_s.strip.chomp("/").presence
+    end
+
+    def normalize_timezone
+      return self.timezone = nil if timezone.blank?
+
+      self.timezone = ActiveSupport::TimeZone[timezone]&.tzinfo&.name || timezone
+    end
+
+    def site_url_is_http_origin
+      return if site_url.blank?
+
+      uri = URI.parse(site_url)
+      return if uri.is_a?(URI::HTTP) && uri.host.present? && uri.userinfo.nil? && uri.path.blank? && uri.query.nil? && uri.fragment.nil?
+
+      errors.add(:site_url, "must be an HTTP(S) origin without a path, query, or fragment")
+    rescue URI::InvalidURIError
+      errors.add(:site_url, "must be a valid URL")
+    end
+
+    def clear_i18n_cache
+      Postnhost::Settings::I18nOverrides.clear_cache!
+    end
+  end
+end

data/app/models/postnhost/site_script.rb

@@ -0,0 +1,11 @@
+module Postnhost
+  class SiteScript < ApplicationRecord
+    self.table_name = "postnhost_site_scripts"
+
+    PLACEMENTS = %w[head body_start body_end].freeze
+
+    belongs_to :setting, class_name: "Postnhost::Setting", touch: true
+
+    validates :placement, inclusion: { in: PLACEMENTS }
+  end
+end

data/app/models/postnhost/snapshot/article.rb

@@ -0,0 +1,142 @@
+module Postnhost
+  class Snapshot::Article < ApplicationRecord
+    self.table_name = "postnhost_article_snapshots"
+
+    MAX_SUGGESTIONS = 3
+    SCALAR_ATTRIBUTES = %i[
+      language_id title title_tag og_title schema_headline schema_article_type meta_description
+      custom_excerpt auto_excerpt use_excerpt_as_meta_description content slug cover_image_alt top_pick
+    ].freeze
+
+    belongs_to :article, class_name: "Postnhost::Article"
+    belongs_to :language, class_name: "Postnhost::Language"
+    belongs_to :paper_trail_version, class_name: "Postnhost::Version"
+
+    has_many :article_snapshot_categories, class_name: "Postnhost::Snapshot::ArticleCategory",
+                                           foreign_key: :article_snapshot_id, dependent: :destroy,
+                                           inverse_of: :article_snapshot
+    has_many :categories, through: :article_snapshot_categories
+    has_many :article_snapshot_authors, -> { order(:position) }, class_name: "Postnhost::Snapshot::ArticleAuthor",
+                                                                 foreign_key: :article_snapshot_id,
+                                                                 dependent: :destroy, inverse_of: :article_snapshot
+    has_many :authors, through: :article_snapshot_authors, source: :user
+    has_many :article_snapshot_suggestions, -> { order(:position) },
+             class_name: "Postnhost::Snapshot::ArticleSuggestion", foreign_key: :article_snapshot_id,
+             dependent: :destroy, inverse_of: :article_snapshot
+    # Variant snapshots intentionally survive base unpublishing.
+    has_many :article_variant_snapshots, class_name: "Postnhost::Snapshot::ArticleVariant", primary_key: :article_id,
+                                         inverse_of: :article_snapshot, dependent: nil
+
+    validates :title, :content, :slug, :published_at, presence: true
+    validates :article_id, :paper_trail_version_id, :slug, uniqueness: true
+    validates :slug, format: { with: /\A[a-z0-9-]+\z/, message: "can only contain lowercase letters, numbers, and hyphens" }
+
+    scope :for_language, ->(language) { where(language:) }
+    scope :top_picks, -> { where(top_pick: true) }
+    scope :by_author, lambda { |author|
+      joins(:article_snapshot_authors).merge(Postnhost::Snapshot::ArticleAuthor.where(user: author))
+    }
+    scope :in_category, lambda { |category|
+      joins(:article_snapshot_categories).merge(Postnhost::Snapshot::ArticleCategory.where(category:))
+    }
+    scope :recent_first, -> { order(published_at: :desc) }
+    scope :with_language, -> { includes(:language) }
+    scope :with_categories, -> { includes(:categories) }
+    scope :with_authors, -> { includes(article_snapshot_authors: :user) }
+
+    def self.matching(query)
+      return all if query.blank?
+
+      where(
+        <<~SQL.squish,
+          LOWER(postnhost_article_snapshots.title) LIKE :search OR
+          LOWER(postnhost_article_snapshots.content) LIKE :search OR
+          LOWER(postnhost_article_snapshots.meta_description) LIKE :search
+        SQL
+        search: "%#{sanitize_sql_like(query.downcase)}%"
+      )
+    end
+
+    def published?
+      true
+    end
+
+    def cover_image
+      @cover_image ||= PublishedCoverImage.new(article_id:, identifier: cover_image_identifier)
+    end
+
+    def cover_image?
+      cover_image.present?
+    end
+
+    def differs_from?(draft)
+      scalar_changes?(draft) ||
+        cover_image_identifier != draft.cover_image.identifier.presence ||
+        category_ids.sort != draft.category_ids.sort ||
+        snapshot_author_ids != draft.article_authors.order(:position, :id).pluck(:user_id) ||
+        snapshot_suggestion_ids != draft.article_suggestions.order(:position, :id).pluck(:suggested_article_id)
+    end
+
+    def suggestions_for(language:, limit: MAX_SUGGESTIONS)
+      @suggestions_by_language_and_limit ||= {}
+      @suggestions_by_language_and_limit[[language.id, limit]] ||= begin
+        manual = manual_suggestions(limit:)
+        if manual.size >= limit
+          preload_suggestion_associations(manual)
+        else
+          remaining = limit - manual.size
+          candidates = automatic_suggestions(language:, exclude_ids: manual.map(&:article_id), limit: remaining * 3)
+          suggestions = manual + candidates.sample(remaining, random: Random.new(article_id))
+          preload_suggestion_associations(suggestions)
+        end
+      end
+    end
+
+    private
+
+    def scalar_changes?(draft)
+      SCALAR_ATTRIBUTES.any? { |attribute| public_send(attribute) != draft.public_send(attribute) }
+    end
+
+    def snapshot_author_ids
+      article_snapshot_authors.map(&:user_id)
+    end
+
+    def snapshot_suggestion_ids
+      article_snapshot_suggestions.map(&:suggested_article_id)
+    end
+
+    def manual_suggestions(limit:)
+      ids = article_snapshot_suggestions.limit(limit).pluck(:suggested_article_id)
+      snapshots = self.class.where(article_id: ids).index_by(&:article_id)
+      ids.filter_map { |id| snapshots[id] }
+    end
+
+    def automatic_suggestions(language:, exclude_ids:, limit:)
+      exclusions = [article_id, *exclude_ids]
+      category_matches = self.class
+                             .joins(:article_snapshot_categories)
+                             .where(language:, postnhost_article_snapshot_categories: { category_id: category_ids })
+                             .where.not(article_id: exclusions)
+                             .distinct
+                             .limit(limit)
+                             .to_a
+
+      return category_matches if category_matches.size >= limit
+
+      filler = self.class.where(language:)
+                   .where.not(article_id: [*exclusions, *category_matches.map(&:article_id)])
+                   .limit(limit - category_matches.size)
+                   .to_a
+      category_matches + filler
+    end
+
+    def preload_suggestion_associations(suggestions)
+      ActiveRecord::Associations::Preloader.new(
+        records: suggestions,
+        associations: [:categories, { article_snapshot_authors: :user }]
+      ).call
+      suggestions
+    end
+  end
+end

data/app/models/postnhost/snapshot/article_author.rb

@@ -0,0 +1,11 @@
+module Postnhost
+  class Snapshot::ArticleAuthor < ApplicationRecord
+    self.table_name = "postnhost_article_snapshot_authors"
+
+    belongs_to :article_snapshot, class_name: "Postnhost::Snapshot::Article", inverse_of: :article_snapshot_authors
+    belongs_to :user, class_name: "Postnhost::User"
+
+    validates :user_id, :position, uniqueness: { scope: :article_snapshot_id }
+    validates :position, numericality: { greater_than_or_equal_to: 0 }
+  end
+end

data/app/models/postnhost/snapshot/article_category.rb

@@ -0,0 +1,10 @@
+module Postnhost
+  class Snapshot::ArticleCategory < ApplicationRecord
+    self.table_name = "postnhost_article_snapshot_categories"
+
+    belongs_to :article_snapshot, class_name: "Postnhost::Snapshot::Article", inverse_of: :article_snapshot_categories
+    belongs_to :category, class_name: "Postnhost::Category"
+
+    validates :category_id, uniqueness: { scope: :article_snapshot_id }
+  end
+end

data/app/models/postnhost/snapshot/article_suggestion.rb

@@ -0,0 +1,11 @@
+module Postnhost
+  class Snapshot::ArticleSuggestion < ApplicationRecord
+    self.table_name = "postnhost_article_snapshot_suggestions"
+
+    belongs_to :article_snapshot, class_name: "Postnhost::Snapshot::Article", inverse_of: :article_snapshot_suggestions
+    belongs_to :suggested_article, class_name: "Postnhost::Article"
+
+    validates :suggested_article_id, :position, uniqueness: { scope: :article_snapshot_id }
+    validates :position, numericality: { greater_than_or_equal_to: 0 }
+  end
+end

data/app/models/postnhost/snapshot/article_variant.rb

@@ -0,0 +1,60 @@
+module Postnhost
+  class Snapshot::ArticleVariant < ApplicationRecord
+    self.table_name = "postnhost_article_variant_snapshots"
+
+    SCALAR_ATTRIBUTES = %i[
+      language_id title title_tag og_title schema_headline meta_description custom_excerpt auto_excerpt
+      use_excerpt_as_meta_description content
+    ].freeze
+
+    belongs_to :article_variant, class_name: "Postnhost::ArticleVariant"
+    belongs_to :article, class_name: "Postnhost::Article"
+    belongs_to :article_snapshot, class_name: "Postnhost::Snapshot::Article",
+                                  foreign_key: :article_id, primary_key: :article_id,
+                                  inverse_of: :article_variant_snapshots
+    belongs_to :language, class_name: "Postnhost::Language"
+    belongs_to :paper_trail_version, class_name: "Postnhost::Version"
+
+    validates :title, :content, :published_at, presence: true
+    validates :article_variant_id, :paper_trail_version_id, uniqueness: true
+    validates :article_id, uniqueness: { scope: :language_id }
+
+    scope :for_language, ->(language) { where(language:) }
+    scope :top_picks, lambda {
+      joins(:article_snapshot).merge(Postnhost::Snapshot::Article.top_picks)
+    }
+    scope :by_author, lambda { |author|
+      joins(:article_snapshot).merge(Postnhost::Snapshot::Article.by_author(author))
+    }
+    scope :in_category, lambda { |category|
+      joins(:article_snapshot).merge(Postnhost::Snapshot::Article.in_category(category))
+    }
+    scope :recent_first, lambda {
+      joins(:article_snapshot).merge(Postnhost::Snapshot::Article.recent_first)
+    }
+    scope :with_language, -> { includes(:language) }
+    scope :with_categories, -> { includes(article_snapshot: :categories) }
+    scope :with_authors, -> { includes(article_snapshot: { article_snapshot_authors: :user }) }
+
+    def self.matching(query)
+      return all if query.blank?
+
+      where(
+        <<~SQL.squish,
+          LOWER(postnhost_article_variant_snapshots.title) LIKE :search OR
+          LOWER(postnhost_article_variant_snapshots.content) LIKE :search OR
+          LOWER(postnhost_article_variant_snapshots.meta_description) LIKE :search
+        SQL
+        search: "%#{sanitize_sql_like(query.downcase)}%"
+      )
+    end
+
+    def published?
+      true
+    end
+
+    def differs_from?(draft)
+      SCALAR_ATTRIBUTES.any? { |attribute| public_send(attribute) != draft.public_send(attribute) }
+    end
+  end
+end

data/app/models/postnhost/snapshot/page.rb

@@ -0,0 +1,33 @@
+module Postnhost
+  class Snapshot::Page < ApplicationRecord
+    self.table_name = "postnhost_page_snapshots"
+
+    SCALAR_ATTRIBUTES = %i[language_id title title_tag og_title meta_description content slug].freeze
+
+    belongs_to :page, class_name: "Postnhost::Page"
+    belongs_to :language, class_name: "Postnhost::Language"
+    belongs_to :paper_trail_version, class_name: "Postnhost::Version"
+    # Variant snapshots intentionally survive base unpublishing.
+    has_many :page_variant_snapshots, class_name: "Postnhost::Snapshot::PageVariant", primary_key: :page_id,
+                                      inverse_of: :page_snapshot, dependent: nil
+
+    validates :title, :content, :slug, :published_at, presence: true
+    validates :page_id, :paper_trail_version_id, :slug, uniqueness: true
+    validates :slug, format: { with: /\A[a-z0-9-]+\z/, message: "can only contain lowercase letters, numbers, and hyphens" }
+
+    scope :with_page_and_language, -> { includes(:page, :language) }
+    scope :footer_links, -> { where.not(slug: nil).select(:slug, :title).order(:title, :slug) }
+
+    def published?
+      true
+    end
+
+    def differs_from?(draft)
+      SCALAR_ATTRIBUTES.any? { |attribute| public_send(attribute) != draft.public_send(attribute) }
+    end
+
+    def title_for_meta
+      title_tag.presence || title
+    end
+  end
+end

data/app/models/postnhost/snapshot/page_variant.rb

@@ -0,0 +1,41 @@
+module Postnhost
+  class Snapshot::PageVariant < ApplicationRecord
+    self.table_name = "postnhost_page_variant_snapshots"
+
+    SCALAR_ATTRIBUTES = %i[language_id title title_tag og_title meta_description content].freeze
+
+    belongs_to :page_variant, class_name: "Postnhost::PageVariant"
+    belongs_to :page, class_name: "Postnhost::Page"
+    belongs_to :page_snapshot, class_name: "Postnhost::Snapshot::Page",
+                               foreign_key: :page_id, primary_key: :page_id,
+                               inverse_of: :page_variant_snapshots
+    belongs_to :language, class_name: "Postnhost::Language"
+    belongs_to :paper_trail_version, class_name: "Postnhost::Version"
+
+    validates :title, :content, :published_at, presence: true
+    validates :page_variant_id, :paper_trail_version_id, uniqueness: true
+    validates :page_id, uniqueness: { scope: :language_id }
+
+    scope :for_language, ->(language) { where(language:) }
+    scope :with_language, -> { includes(:language) }
+
+    def self.footer_links_for(language)
+      for_language(language)
+        .joins(:page_snapshot)
+        .merge(Postnhost::Snapshot::Page.where.not(slug: nil))
+        .select(
+          Postnhost::Snapshot::Page.arel_table[:slug].as("slug"),
+          arel_table[:title].as("title")
+        )
+        .order(arel_table[:title], Postnhost::Snapshot::Page.arel_table[:slug])
+    end
+
+    def published?
+      true
+    end
+
+    def differs_from?(draft)
+      SCALAR_ATTRIBUTES.any? { |attribute| public_send(attribute) != draft.public_send(attribute) }
+    end
+  end
+end

data/app/models/postnhost/template.rb

@@ -0,0 +1,20 @@
+module Postnhost
+  class Template < ApplicationRecord
+    include Postnhost::PublicRevisionTouch
+
+    self.table_name = "postnhost_templates"
+
+    DEFAULT_NAME = "default"
+    NAMES = [DEFAULT_NAME, "swiss-editorial", "workspace-journal"].freeze
+
+    validates :name, inclusion: { in: NAMES }
+
+    def self.current
+      first_or_create!(name: DEFAULT_NAME)
+    end
+
+    def self.active_name
+      current.name
+    end
+  end
+end

data/app/models/postnhost/user.rb

@@ -0,0 +1,63 @@
+module Postnhost
+  class User < ApplicationRecord
+    include Postnhost::SchemaLocalizable
+    include Postnhost::PublicRevisionTouch
+
+    self.table_name = "postnhost_users"
+
+    has_secure_password
+
+    mount_uploader :avatar_file, Postnhost::AvatarUploader
+
+    has_many :articles, class_name: "Postnhost::Article", dependent: :nullify
+    has_many :article_authors, class_name: "Postnhost::ArticleAuthor", dependent: :destroy
+    has_many :authored_articles, through: :article_authors, source: :article
+    has_many :article_snapshot_authors, class_name: "Postnhost::Snapshot::ArticleAuthor",
+                                        dependent: :restrict_with_error
+    has_many :article_snapshots, through: :article_snapshot_authors
+    has_many :pages, class_name: "Postnhost::Page", dependent: :restrict_with_error
+
+    before_validation :normalize_email
+    before_validation :normalize_slug
+    before_validation :generate_slug_from_name, if: -> { slug.blank? && name.present? }
+
+    validates :email, presence: true, uniqueness: true, format: { with: URI::MailTo::EMAIL_REGEXP }
+    validates :name, presence: true
+    validates :slug, presence: true, uniqueness: true,
+                     format: { with: /\A[a-z0-9-]+\z/, message: "can only contain lowercase letters, numbers, and hyphens" }
+    validates :password, length: { minimum: 6 }, allow_nil: true
+
+    def schema_profile_hash
+      schema_profile.is_a?(Hash) ? schema_profile.deep_stringify_keys : {}
+    end
+
+    def schema_profile_value(key, default: nil)
+      schema_profile_hash[key.to_s].presence || default
+    end
+
+    private
+
+    def normalize_email
+      self.email = email.to_s.strip.downcase
+    end
+
+    def normalize_slug
+      return if slug.nil?
+
+      normalized = slug.to_s.strip.downcase
+      normalized = normalized.gsub(/[^a-z0-9\s-]/, "").gsub(/\s+/, "-").squeeze("-").gsub(/\A-|-$/, "")
+      self.slug = normalized.presence
+    end
+
+    def generate_slug_from_name
+      base_slug = name.to_s.downcase.gsub(/[^a-z0-9\s-]/, "").gsub(/\s+/, "-").squeeze("-").gsub(/\A-|-$/, "")
+      self.slug = base_slug
+      counter = 1
+
+      while self.class.where(slug: slug).where.not(id: id).exists?
+        self.slug = "#{base_slug}-#{counter}"
+        counter += 1
+      end
+    end
+  end
+end

data/app/models/postnhost/version.rb

@@ -0,0 +1,7 @@
+module Postnhost
+  class Version < ApplicationRecord
+    include PaperTrail::VersionConcern
+
+    self.table_name = "postnhost_versions"
+  end
+end

data/app/services/postnhost/base_service.rb

@@ -0,0 +1,17 @@
+module Postnhost
+  class BaseService
+    def self.call(...)
+      new(...).call
+    end
+
+    private
+
+    def success(value = nil, status: nil)
+      ServiceResult.new(value:, errors: [], status:)
+    end
+
+    def failure(message, status: :unprocessable_content)
+      ServiceResult.new(value: nil, errors: Array(message), status:)
+    end
+  end
+end

data/app/services/postnhost/constraints/public_locale_constraint.rb

@@ -0,0 +1,9 @@
+module Postnhost
+  module Constraints
+    class PublicLocaleConstraint
+      def self.matches?(request)
+        Postnhost::PublicRequestContext.for(request).localized_language?
+      end
+    end
+  end
+end

data/app/services/postnhost/constraints/public_route_constraint.rb

@@ -0,0 +1,19 @@
+module Postnhost
+  module Constraints
+    class PublicRouteConstraint
+      def initialize(kind:, parameter:)
+        @kind = kind
+        @parameter = parameter
+      end
+
+      def matches?(request)
+        slug = request.params.fetch(parameter)
+        Postnhost::PublicRequestContext.for(request).resolve_kind(kind, slug).present?
+      end
+
+      private
+
+      attr_reader :kind, :parameter
+    end
+  end
+end

data/app/services/postnhost/onboarding/step_processor.rb

@@ -0,0 +1,27 @@
+module Postnhost
+  module Onboarding
+    class StepProcessor < BaseService
+      STEP_SERVICES = {
+        "1" => Steps::CreateAdminAccount,
+        "2" => Steps::ChooseLanguages,
+        "3" => Steps::SetSiteMetadata,
+        "4" => Steps::FinishSetup,
+        "post_install_done" => Steps::CompletePostInstallChecklist
+      }.freeze
+
+      attr_reader :params, :session
+
+      def initialize(params:, session:)
+        @params = params
+        @session = session
+      end
+
+      def call
+        service_class = STEP_SERVICES[params[:step].to_s]
+        return success({ alert: "Invalid step." }, status: :redirect_onboarding) unless service_class
+
+        service_class.call(params:, session:)
+      end
+    end
+  end
+end

data/app/services/postnhost/onboarding/steps/base.rb

@@ -0,0 +1,52 @@
+module Postnhost
+  module Onboarding
+    module Steps
+      class Base < BaseService
+        SITE_COPY_KEYS = Postnhost::Onboarding::StepAssignment::SITE_COPY_KEYS
+        LANGUAGE_OPTIONS = Postnhost::Onboarding::StepAssignment::LANGUAGE_OPTIONS
+
+        attr_reader :params, :session
+
+        def initialize(params:, session:)
+          @params = params
+          @session = session
+        end
+
+        private
+
+        def render_show(**payload)
+          alert = payload.delete(:alert)
+
+          ServiceResult.new(
+            value: payload.merge(alert:).compact,
+            errors: [alert].compact,
+            status: :render_show
+          )
+        end
+
+        def redirect_onboarding(alert: nil)
+          success({ alert: }.compact, status: :redirect_onboarding)
+        end
+
+        def restart_at_admin_account
+          session[:onboarding_step] = 1
+          redirect_onboarding(alert: "Continue from step 1.")
+        end
+
+        def pending_user
+          id = session[:onboarding_pending_user_id]
+          return if id.blank?
+
+          Postnhost::User.find_by(id:)
+        end
+
+        def reset_onboarding_session!
+          session.delete(:onboarding_pending_user_id)
+          session.delete(:onboarding_step)
+          session.delete(:onboarding_locale)
+          session.delete(:onboarding_language_locales)
+        end
+      end
+    end
+  end
+end