postnhost 0.0.0 → 0.1.0

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

@@ -0,0 +1,66 @@
+module Postnhost
+  module Onboarding
+    module Steps
+      class ChooseLanguages < Base
+        def call
+          return restart_at_admin_account unless pending_user
+
+          options_by_locale = LANGUAGE_OPTIONS.index_by { |option| option[:html_lang] }
+          locales = selected_locales
+          default_locale = selected_default_locale
+          payload = language_selection_payload(locales:, default_locale:)
+
+          return render_show(**payload, alert: "Select at least one language.") if locales.empty?
+          return render_show(**payload, alert: "Choose valid languages.") if locales.any? { |locale| !options_by_locale.key?(locale) }
+
+          return render_show(**payload, alert: "Default language must be one of the selected languages.") unless locales.include?(default_locale)
+
+          replace_languages!(locales:, default_locale:, options_by_locale:)
+          advance_session(locales:, default_locale:)
+          redirect_onboarding
+        end
+
+        private
+
+        def replace_languages!(locales:, default_locale:, options_by_locale:)
+          Postnhost::Language.transaction do
+            Postnhost::Language.destroy_all
+            locales.each do |locale|
+              option = options_by_locale.fetch(locale)
+              Postnhost::Language.create!(
+                name: option[:name],
+                html_lang: option[:html_lang],
+                default: option[:html_lang] == default_locale
+              )
+            end
+          end
+        end
+
+        def advance_session(locales:, default_locale:)
+          session[:onboarding_locale] = default_locale
+          session[:onboarding_language_locales] = locales
+          session[:onboarding_step] = 3
+        end
+
+        def language_selection_payload(locales:, default_locale:)
+          {
+            step: 2,
+            language_options: LANGUAGE_OPTIONS,
+            selected_language_locales: locales,
+            selected_default_locale: default_locale
+          }
+        end
+
+        def selected_locales
+          locales = Array(params[:language_locales]).map(&:to_s).compact_blank.uniq
+          locales = [params[:html_lang].to_s] if locales.empty? && params[:html_lang].present?
+          locales
+        end
+
+        def selected_default_locale
+          params[:default_locale].presence || params[:html_lang].presence || "en"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Postnhost
+  module Onboarding
+    module Steps
+      class CompletePostInstallChecklist < Base
+        def call
+          session.delete(:onboarding_post_install_checklist)
+          success(status: :redirect_articles)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Postnhost
+  module Onboarding
+    module Steps
+      class CreateAdminAccount < Base
+        def call
+          user = Postnhost::User.new(admin_user_params)
+
+          return success({ alert: "An account already exists." }, status: :redirect_new_session) unless Postnhost::User.none?
+
+          if user.save
+            session[:onboarding_pending_user_id] = user.id
+            session[:onboarding_step] = 2
+            redirect_onboarding
+          else
+            render_show(step: 1, user:)
+          end
+        end
+
+        private
+
+        def admin_user_params
+          raw = params[:postnhost_user].presence || params[:user].presence || ActionController::Parameters.new
+          raw.permit(:name, :email, :password)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Postnhost
+  module Onboarding
+    module Steps
+      class FinishSetup < Base
+        def call
+          user = pending_user
+
+          unless user
+            reset_onboarding_session!
+            return redirect_onboarding(alert: "Continue setup from the beginning.")
+          end
+
+          Postnhost::SampleData.seed!(user:) if generate_sample?
+
+          reset_onboarding_session!
+          success({ user: }, status: :finish_setup)
+        end
+
+        private
+
+        def generate_sample?
+          %w[1 true yes on].include?(params[:generate_sample].to_s.downcase)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Postnhost
+  module Onboarding
+    module Steps
+      class SetSiteMetadata < Base
+        def call
+          return restart_at_admin_account unless pending_user
+
+          locale = session[:onboarding_locale].presence || I18n.default_locale.to_s
+          translations = translation_params
+          setting = Postnhost::Setting.current
+          merged = Postnhost::Settings::I18nOverrides.merge_locale_overrides(
+            setting.locale_overrides,
+            locale,
+            translations
+          )
+
+          unless setting.update(
+            locale_overrides: merged,
+            site_url: params[:site_url],
+            site_indexing: params[:site_indexing]
+          )
+            return render_show(
+              **site_metadata_payload(
+                values: translations,
+                locale:,
+                site_url: params[:site_url],
+                site_indexing: params[:site_indexing]
+              ),
+              alert: setting_error_message(setting)
+            )
+          end
+
+          session[:onboarding_step] = 4
+          redirect_onboarding
+        end
+
+        private
+
+        def setting_error_message(setting)
+          site_url_error = setting.errors[:site_url].to_sentence
+          return "Site URL #{site_url_error}" if site_url_error.present?
+
+          setting.errors.full_messages.to_sentence.presence || "Could not save site settings."
+        end
+
+        def site_metadata_payload(values:, locale:, site_url:, site_indexing:)
+          {
+            step: 3,
+            locale:,
+            site_url: site_url.to_s,
+            site_indexing: site_indexing.to_s,
+            site_copy: SITE_COPY_KEYS.index_with { |key| values[key].to_s }
+          }
+        end
+
+        def translation_params
+          raw = params[:translations]
+          permitted =
+            if raw.is_a?(ActionController::Parameters)
+              raw.permit(*SITE_COPY_KEYS)
+            else
+              {}
+            end
+
+          SITE_COPY_KEYS.index_with { |key| permitted[key].to_s }
+        end
+      end
+    end
+  end
+end

data/app/services/postnhost/public_navigation_targets.rb

@@ -0,0 +1,67 @@
+module Postnhost
+  class PublicNavigationTargets < BaseService
+    Targets = Data.define(:records, :variants)
+
+    def initialize(items:, language:)
+      @items = items
+      @language = language
+    end
+
+    def call
+      records = {
+        "article" => article_snapshots,
+        "page" => page_snapshots,
+        "category" => categories
+      }
+
+      success(Targets.new(records:, variants: variants_for(records)))
+    end
+
+    private
+
+    attr_reader :items, :language
+
+    def target_ids(kind)
+      items.filter_map { |item| item.target_id if item.kind == "link" && item.target_kind == kind }.uniq
+    end
+
+    def article_snapshots
+      Postnhost::Snapshot::Article.where(article_id: target_ids("article")).index_by(&:article_id)
+    end
+
+    def page_snapshots
+      Postnhost::Snapshot::Page.where(page_id: target_ids("page")).index_by(&:page_id)
+    end
+
+    def categories
+      scope = category_scope
+      scope = scope.includes(:category_variants) unless language.default?
+      scope.distinct.index_by(&:id)
+    end
+
+    def category_scope
+      scope = Postnhost::Category.where(id: target_ids("category"))
+      return scope.joins(:article_snapshot_categories) if language.default?
+
+      scope.joins(article_snapshot_categories: { article_snapshot: :article_variant_snapshots })
+           .where(postnhost_article_variant_snapshots: { language_id: language.id })
+    end
+
+    def variants_for(records)
+      return {} if language.default?
+
+      {
+        Postnhost::Snapshot::Article.name => article_variants(records.fetch("article")),
+        Postnhost::Snapshot::Page.name => page_variants(records.fetch("page"))
+      }
+    end
+
+    def article_variants(articles)
+      Postnhost::Snapshot::ArticleVariant.where(article_id: articles.keys, language:).index_by(&:article_id)
+    end
+
+    def page_variants(pages)
+      Postnhost::Snapshot::PageVariant.where(page_id: pages.keys, language:).index_by(&:page_id)
+    end
+  end
+end

data/app/services/postnhost/public_request_context.rb

@@ -0,0 +1,101 @@
+module Postnhost
+  class PublicRequestContext
+    ENV_KEY = "postnhost.public_request_context"
+    Resolution = Data.define(:kind, :record) do
+      delegate :id, to: :record, prefix: true
+    end
+
+    def self.for(request)
+      request.env[ENV_KEY] ||= new(request)
+    end
+
+    def initialize(request)
+      @request = request
+    end
+
+    def setting
+      @setting ||= Postnhost::Setting.current
+    end
+
+    def template_name
+      @template_name ||= Postnhost::Template.active_name
+    end
+
+    def public_site_revision
+      @public_site_revision ||= Postnhost::PublicSiteRevision.current
+    end
+
+    def requested_language
+      return @requested_language if defined?(@requested_language)
+
+      @requested_language = Postnhost::Language.find_by(html_lang: requested_locale) if requested_locale.present?
+    end
+
+    def default_language
+      return @default_language if defined?(@default_language)
+
+      @default_language = Postnhost::Language.blog_default
+    end
+
+    attr_writer :default_language
+
+    def localized_language?
+      requested_language.present? && !requested_language.default?
+    end
+
+    def resolve(slug)
+      %i[category article page].each do |kind|
+        resolution = resolve_kind(kind, slug)
+        return resolution if resolution
+      end
+
+      nil
+    end
+
+    def resolve_kind(kind, slug)
+      @resolutions ||= {}
+      key = [kind, slug, requested_language&.id]
+      return @resolutions[key] if @resolutions.key?(key)
+
+      record = route_scope(kind).find_by(slug:)
+      @resolutions[key] = record ? Resolution.new(kind:, record:) : nil
+    end
+
+    private
+
+    attr_reader :request
+
+    def requested_locale
+      request.path_parameters[:locale].presence || request.params[:locale].presence
+    end
+
+    def route_scope(kind)
+      case kind
+      when :category then category_scope
+      when :article then article_scope
+      when :page then page_scope
+      else raise ArgumentError, "Unknown public route kind: #{kind}"
+      end
+    end
+
+    def category_scope
+      Postnhost::Category.joins(:article_snapshot_categories)
+    end
+
+    def article_scope
+      return Postnhost::Snapshot::Article.all unless localized_language?
+
+      Postnhost::Snapshot::Article
+        .joins(:article_variant_snapshots)
+        .where(postnhost_article_variant_snapshots: { language_id: requested_language.id })
+    end
+
+    def page_scope
+      return Postnhost::Snapshot::Page.all unless localized_language?
+
+      Postnhost::Snapshot::Page
+        .joins(:page_variant_snapshots)
+        .where(postnhost_page_variant_snapshots: { language_id: requested_language.id })
+    end
+  end
+end

data/app/services/postnhost/publishing/article_variants/publish.rb

@@ -0,0 +1,26 @@
+module Postnhost
+  module Publishing
+    class ArticleVariants::Publish < BaseService
+      def initialize(article_variant:)
+        @article_variant = article_variant
+      end
+
+      def call
+        snapshot = Revision.hold do
+          article_variant.article.lock!
+          article_variant.lock!
+          ArticleVariants::SnapshotWriter.new(variant: article_variant).call
+        end
+        success(snapshot, status: :ok)
+      rescue Error => e
+        failure(e.messages)
+      rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique => e
+        failure(e.message)
+      end
+
+      private
+
+      attr_reader :article_variant
+    end
+  end
+end

data/app/services/postnhost/publishing/article_variants/publish_many.rb

@@ -0,0 +1,23 @@
+module Postnhost
+  module Publishing
+    class ArticleVariants::PublishMany < BaseService
+      def initialize(article:, ids:)
+        @article = article
+        @ids = ids
+      end
+
+      def call
+        BulkTransition.call(
+          scope: article.article_variants,
+          ids:,
+          service_class: ArticleVariants::Publish,
+          argument_name: :article_variant
+        )
+      end
+
+      private
+
+      attr_reader :article, :ids
+    end
+  end
+end

data/app/services/postnhost/publishing/article_variants/snapshot_writer.rb

@@ -0,0 +1,44 @@
+module Postnhost
+  module Publishing
+    class ArticleVariants::SnapshotWriter
+      ATTRIBUTES = %i[
+        language_id title title_tag og_title schema_headline meta_description custom_excerpt auto_excerpt
+        use_excerpt_as_meta_description content
+      ].freeze
+
+      def initialize(variant:)
+        @variant = variant
+      end
+
+      def call
+        validate!
+        version = variant.paper_trail.save_with_version
+        raise Error, "could not capture the snapshot source version" unless version&.persisted?
+
+        snapshot = variant.article_variant_snapshot || variant.build_article_variant_snapshot
+        snapshot.assign_attributes(
+          variant.attributes.symbolize_keys.slice(*ATTRIBUTES).merge(
+            article_id: variant.article_id,
+            paper_trail_version: version
+          )
+        )
+        snapshot.published_at ||= Time.current
+        snapshot.save!
+        snapshot
+      end
+
+      private
+
+      attr_reader :variant
+
+      def validate!
+        errors = []
+        errors << "base article must be published" unless variant.article.article_snapshot
+        errors << "title can't be blank" if variant.title.blank?
+        errors << "content can't be blank" if variant.content.blank?
+        errors << "translation is still being generated" if variant.generating?
+        raise Error, errors if errors.any?
+      end
+    end
+  end
+end

data/app/services/postnhost/publishing/article_variants/unpublish.rb

@@ -0,0 +1,27 @@
+module Postnhost
+  module Publishing
+    class ArticleVariants::Unpublish < BaseService
+      def initialize(article_variant:)
+        @article_variant = article_variant
+      end
+
+      def call
+        snapshot = article_variant.article_variant_snapshot
+        return failure("Article variant snapshot was not found", status: :not_found) unless snapshot
+
+        Revision.hold do
+          article_variant.article.lock!
+          article_variant.lock!
+          snapshot.destroy!
+        end
+        success(true, status: :ok)
+      rescue ActiveRecord::RecordInvalid => e
+        failure(e.message)
+      end
+
+      private
+
+      attr_reader :article_variant
+    end
+  end
+end

data/app/services/postnhost/publishing/article_variants/unpublish_many.rb

@@ -0,0 +1,23 @@
+module Postnhost
+  module Publishing
+    class ArticleVariants::UnpublishMany < BaseService
+      def initialize(article:, ids:)
+        @article = article
+        @ids = ids
+      end
+
+      def call
+        BulkTransition.call(
+          scope: article.article_variants,
+          ids:,
+          service_class: ArticleVariants::Unpublish,
+          argument_name: :article_variant
+        )
+      end
+
+      private
+
+      attr_reader :article, :ids
+    end
+  end
+end

data/app/services/postnhost/publishing/articles/publish.rb

@@ -0,0 +1,25 @@
+module Postnhost
+  module Publishing
+    class Articles::Publish < BaseService
+      def initialize(article:)
+        @article = article
+      end
+
+      def call
+        snapshot = Revision.hold do
+          article.lock!
+          Articles::SnapshotWriter.new(article:).call
+        end
+        success(snapshot, status: :ok)
+      rescue Error => e
+        failure(e.messages)
+      rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique => e
+        failure(e.message)
+      end
+
+      private
+
+      attr_reader :article
+    end
+  end
+end

data/app/services/postnhost/publishing/articles/publish_scheduled.rb

@@ -0,0 +1,42 @@
+module Postnhost
+  module Publishing
+    class Articles::PublishScheduled < BaseService
+      def initialize(article_id:, job_id:)
+        @article_id = article_id
+        @job_id = job_id
+      end
+
+      def call
+        article = Article.find_by(id: article_id)
+        return failure("Article was not found", status: :not_found) unless article
+        return failure("Article is not due for this job") unless due_for_this_job?(article)
+
+        snapshot = Revision.hold do
+          article.lock!
+          Articles::SnapshotWriter.new(article:).call
+        end
+        success(snapshot, status: :ok)
+      rescue Error => e
+        record_publication_error(article, e.message)
+        failure(e.messages)
+      rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique => e
+        record_publication_error(article, e.message)
+        failure(e.message)
+      end
+
+      private
+
+      attr_reader :article_id, :job_id
+
+      def due_for_this_job?(article)
+        article.scheduled_at.present? &&
+          article.scheduled_at <= Time.current &&
+          article.scheduled_job_id == job_id
+      end
+
+      def record_publication_error(article, message)
+        article.update_columns(publication_error: message, updated_at: Time.current)
+      end
+    end
+  end
+end

data/app/services/postnhost/publishing/articles/snapshot_writer.rb

@@ -0,0 +1,84 @@
+module Postnhost
+  module Publishing
+    class Articles::SnapshotWriter
+      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
+
+      def initialize(article:)
+        @article = article
+      end
+
+      def call
+        validate!
+        version = article.paper_trail.save_with_version
+        raise Error, "could not capture the snapshot source version" unless version&.persisted?
+
+        snapshot = article.article_snapshot || article.build_article_snapshot
+        snapshot.assign_attributes(snapshot_attributes.merge(paper_trail_version: version))
+        snapshot.published_at ||= Time.current
+        snapshot.save!
+        replace_categories!(snapshot)
+        replace_authors!(snapshot)
+        replace_suggestions!(snapshot)
+        clear_schedule!
+        snapshot
+      end
+
+      private
+
+      attr_reader :article
+
+      def validate!
+        errors = []
+        errors << "title can't be blank" if article.title.blank?
+        errors << "content can't be blank" if article.content.blank?
+        errors << "slug can't be blank" if article.slug.blank?
+        errors << "language must exist" if article.language.blank?
+        raise Error, errors if errors.any?
+
+        RouteValidator.validate!(slug: article.slug, article_id: article.id)
+      end
+
+      def snapshot_attributes
+        article.attributes.symbolize_keys.slice(*ATTRIBUTES).merge(
+          cover_image_identifier: article.cover_image.identifier.presence
+        )
+      end
+
+      def replace_categories!(snapshot)
+        category_ids = article.article_categories.order(:id).pluck(:category_id)
+        replace_joins!(snapshot.article_snapshot_categories, category_ids.map { |id| { category_id: id } })
+      end
+
+      def replace_authors!(snapshot)
+        user_ids = article.article_authors.order(:position, :id).pluck(:user_id)
+        rows = user_ids.each_with_index.map { |id, position| { user_id: id, position: } }
+        replace_joins!(snapshot.article_snapshot_authors, rows)
+      end
+
+      def replace_suggestions!(snapshot)
+        suggested_ids = article.article_suggestions.order(:position, :id).pluck(:suggested_article_id)
+        rows = suggested_ids.each_with_index.map { |id, position| { suggested_article_id: id, position: } }
+        replace_joins!(snapshot.article_snapshot_suggestions, rows)
+      end
+
+      # Deleting before inserting keeps the (snapshot, position) unique indexes satisfied without
+      # per-row validation round trips; the indexes and check constraints enforce the same invariants.
+      def replace_joins!(association, rows)
+        association.delete_all
+        association.insert_all(rows) if rows.any?
+        association.reset
+      end
+
+      def clear_schedule!
+        SolidQueue::Job.find_by(active_job_id: article.scheduled_job_id)&.destroy! if article.scheduled_job_id.present? && defined?(SolidQueue::Job)
+
+        return if article.scheduled_at.blank? && article.scheduled_job_id.blank? && article.publication_error.blank?
+
+        article.update!(scheduled_at: nil, scheduled_job_id: nil, publication_error: nil)
+      end
+    end
+  end
+end