postnhost 0.0.0 → 0.1.1

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

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

data/app/services/postnhost/publishing/bulk_transition.rb

@@ -0,0 +1,63 @@
+module Postnhost
+  module Publishing
+    class BulkTransition < BaseService
+      def initialize(scope:, ids:, service_class:, argument_name:)
+        @scope = scope
+        @ids = ids
+        @service_class = service_class
+        @argument_name = argument_name
+      end
+
+      def call
+        normalized_ids = normalize_ids
+        return failure("Select at least one translation") if normalized_ids.empty?
+
+        records = scope.where(id: normalized_ids).order(:id).to_a
+        successes, failures = transition_all(records)
+        (normalized_ids - records.map(&:id)).each { |id| failures[id] = ["Translation was not found"] }
+
+        success({ successes:, failures: }, status: failures.empty? ? :ok : :unprocessable_content)
+      rescue ArgumentError, TypeError
+        failure("Translation IDs must be integers")
+      end
+
+      private
+
+      attr_reader :scope, :ids, :service_class, :argument_name
+
+      def transition_all(records)
+        successes = []
+        failures = {}
+        return [successes, failures] if records.empty?
+
+        Revision.hold do
+          records.each do |record|
+            result = transition(record)
+            if result.success?
+              successes << record
+            else
+              failures[record.id] = result.errors
+            end
+          end
+        end
+
+        [successes, failures]
+      end
+
+      # The batch shares one revision lock, so each record needs its own savepoint to keep a
+      # partial write from a failed record out of the records that succeeded.
+      def transition(record)
+        result = nil
+        ApplicationRecord.transaction(requires_new: true) do
+          result = service_class.call(argument_name => record)
+          raise ActiveRecord::Rollback unless result.success?
+        end
+        result
+      end
+
+      def normalize_ids
+        Array(ids).compact_blank.map { |id| id.is_a?(Integer) ? id : Integer(id, 10) }.uniq.sort
+      end
+    end
+  end
+end

data/app/services/postnhost/publishing/error.rb

@@ -0,0 +1,12 @@
+module Postnhost
+  module Publishing
+    class Error < StandardError
+      attr_reader :messages
+
+      def initialize(messages)
+        @messages = Array(messages)
+        super(@messages.join(", "))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Postnhost
+  module Publishing
+    class PageVariants::Publish < BaseService
+      def initialize(page_variant:)
+        @page_variant = page_variant
+      end
+
+      def call
+        snapshot = Revision.hold do
+          page_variant.page.lock!
+          page_variant.lock!
+          PageVariants::SnapshotWriter.new(variant: page_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 :page_variant
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Postnhost
+  module Publishing
+    class PageVariants::PublishMany < BaseService
+      def initialize(page:, ids:)
+        @page = page
+        @ids = ids
+      end
+
+      def call
+        BulkTransition.call(
+          scope: page.page_variants,
+          ids:,
+          service_class: PageVariants::Publish,
+          argument_name: :page_variant
+        )
+      end
+
+      private
+
+      attr_reader :page, :ids
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Postnhost
+  module Publishing
+    class PageVariants::SnapshotWriter
+      ATTRIBUTES = %i[language_id title title_tag og_title 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.page_variant_snapshot || variant.build_page_variant_snapshot
+        snapshot.assign_attributes(
+          variant.attributes.symbolize_keys.slice(*ATTRIBUTES).merge(
+            page_id: variant.page_id,
+            paper_trail_version: version
+          )
+        )
+        snapshot.published_at ||= Time.current
+        snapshot.save!
+        snapshot
+      end
+
+      private
+
+      attr_reader :variant
+
+      def validate!
+        errors = []
+        errors << "base page must be published" unless variant.page.page_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/page_variants/unpublish.rb

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

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

@@ -0,0 +1,23 @@
+module Postnhost
+  module Publishing
+    class PageVariants::UnpublishMany < BaseService
+      def initialize(page:, ids:)
+        @page = page
+        @ids = ids
+      end
+
+      def call
+        BulkTransition.call(
+          scope: page.page_variants,
+          ids:,
+          service_class: PageVariants::Unpublish,
+          argument_name: :page_variant
+        )
+      end
+
+      private
+
+      attr_reader :page, :ids
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Postnhost
+  module Publishing
+    class Pages::Publish < BaseService
+      def initialize(page:)
+        @page = page
+      end
+
+      def call
+        snapshot = Revision.hold do
+          page.lock!
+          Pages::SnapshotWriter.new(page:).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 :page
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Postnhost
+  module Publishing
+    class Pages::SnapshotWriter
+      ATTRIBUTES = %i[language_id title title_tag og_title meta_description content slug].freeze
+
+      def initialize(page:)
+        @page = page
+      end
+
+      def call
+        validate!
+        version = page.paper_trail.save_with_version
+        raise Error, "could not capture the snapshot source version" unless version&.persisted?
+
+        snapshot = page.page_snapshot || page.build_page_snapshot
+        snapshot.assign_attributes(page.attributes.symbolize_keys.slice(*ATTRIBUTES).merge(paper_trail_version: version))
+        snapshot.published_at ||= Time.current
+        snapshot.save!
+        snapshot
+      end
+
+      private
+
+      attr_reader :page
+
+      def validate!
+        errors = []
+        errors << "title can't be blank" if page.title.blank?
+        errors << "content can't be blank" if page.content.blank?
+        errors << "slug can't be blank" if page.slug.blank?
+        errors << "language must exist" if page.language.blank?
+        raise Error, errors if errors.any?
+
+        RouteValidator.validate!(slug: page.slug, page_id: page.id)
+      end
+    end
+  end
+end

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

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

data/app/services/postnhost/publishing/revision.rb

@@ -0,0 +1,37 @@
+module Postnhost
+  module Publishing
+    # Serializes publication transitions on the singleton public site revision row.
+    #
+    # The outermost hold owns the transaction, the row lock, and a single revision bump.
+    # Nested holds join it, so a bulk transition locks once and publishes as one public change
+    # instead of invalidating public caches per record.
+    class Revision
+      STATE_KEY = :postnhost_publishing_revision
+
+      def self.hold
+        return yield if held
+
+        ApplicationRecord.transaction do
+          self.held = PublicSiteRevision.locked
+          begin
+            result = yield
+            held.bump!
+            result
+          ensure
+            self.held = nil
+          end
+        end
+      end
+
+      def self.held
+        ActiveSupport::IsolatedExecutionState[STATE_KEY]
+      end
+
+      def self.held=(revision)
+        ActiveSupport::IsolatedExecutionState[STATE_KEY] = revision
+      end
+
+      private_class_method :held=
+    end
+  end
+end

data/app/services/postnhost/publishing/route_validator.rb

@@ -0,0 +1,41 @@
+module Postnhost
+  module Publishing
+    class RouteValidator
+      RESERVED_SLUGS = %w[authors search sitemap.xml sitemap.xsl].freeze
+
+      def self.validate!(slug:, article_id: nil, page_id: nil)
+        errors = []
+        errors << "slug has already been published by an article" if article_conflict?(slug, article_id)
+        errors << "slug has already been published by a page" if page_conflict?(slug, page_id)
+        errors << "slug conflicts with a category route" if Postnhost::Category.exists?(slug:)
+        errors << "slug conflicts with a static route" if static_slugs.include?(slug)
+        raise Error, errors if errors.any?
+      end
+
+      def self.article_conflict?(slug, article_id)
+        scope = Postnhost::Snapshot::Article.where(slug:)
+        scope = scope.where.not(article_id:) if article_id
+        scope.exists?
+      end
+
+      def self.page_conflict?(slug, page_id)
+        scope = Postnhost::Snapshot::Page.where(slug:)
+        scope = scope.where.not(page_id:) if page_id
+        scope.exists?
+      end
+
+      def self.static_slugs
+        @static_slugs ||= begin
+          paths = [
+            Rails.root.join("app/views/postnhost/static_pages/*.html.erb"),
+            Postnhost::Engine.root.join("app/views/postnhost/static_pages/*.html.erb")
+          ].flat_map { |pattern| Dir[pattern.to_s] }
+
+          (RESERVED_SLUGS + paths.map { |path| File.basename(path, ".html.erb") }).to_set
+        end
+      end
+
+      private_class_method :article_conflict?, :page_conflict?, :static_slugs
+    end
+  end
+end

data/app/services/postnhost/publishing/versions/restore_draft.rb

@@ -0,0 +1,64 @@
+module Postnhost
+  module Publishing
+    class Versions::RestoreDraft < BaseService
+      ATTRIBUTES = {
+        "Postnhost::Article" => %i[
+          title title_tag og_title schema_headline schema_article_type meta_description custom_excerpt
+          use_excerpt_as_meta_description content slug cover_image_alt cover_image
+        ],
+        "Postnhost::ArticleVariant" => %i[
+          title title_tag og_title schema_headline meta_description custom_excerpt use_excerpt_as_meta_description content
+        ],
+        "Postnhost::Page" => %i[title title_tag og_title meta_description content slug],
+        "Postnhost::PageVariant" => %i[title title_tag og_title meta_description content]
+      }.freeze
+
+      def initialize(record:, version:)
+        @record = record
+        @version = version
+      end
+
+      def call
+        restored = record.class.transaction do
+          record.lock!
+          restore_locked!
+        end
+        success(restored, status: :ok)
+      rescue Error => e
+        failure(e.messages)
+      rescue ActiveRecord::RecordInvalid => e
+        failure(e.message)
+      end
+
+      def restore_locked!
+        validate_version!
+        versioned = version.reify
+        raise Error, "Version cannot be restored" unless versioned
+
+        attributes.each do |attribute|
+          if attribute == :cover_image
+            record.write_attribute(:cover_image, versioned.cover_image.identifier.presence)
+          else
+            record.public_send("#{attribute}=", versioned.public_send(attribute))
+          end
+        end
+        record.save!
+        record
+      end
+
+      private
+
+      attr_reader :record, :version
+
+      def attributes
+        ATTRIBUTES.fetch(record.class.name) { raise Error, "Unsupported snapshot record type" }
+      end
+
+      def validate_version!
+        return if version.is_a?(Postnhost::Version) && version.item_type == record.class.name && version.item_id == record.id
+
+        raise Error, "Version does not belong to this record"
+      end
+    end
+  end
+end

data/app/services/postnhost/service_result.rb

@@ -0,0 +1,7 @@
+module Postnhost
+  ServiceResult = Struct.new(:value, :errors, :status, keyword_init: true) do
+    def success?
+      errors.blank?
+    end
+  end
+end