postnhost 0.1.0 → 0.2.0

data/app/controllers/postnhost/api/v1/mcp_controller.rb

@@ -0,0 +1,49 @@
+module Postnhost
+  module Api
+    module V1
+      class McpController < Api::BaseController
+        before_action :validate_transport!
+
+        def create
+          message = JSON.parse(request.raw_post)
+          unless message.is_a?(Hash)
+            render json: { jsonrpc: "2.0", id: nil, error: { code: -32_600, message: "Invalid Request" } }, status: :bad_request
+            return
+          end
+          result = Management::Mcp.new(user: api_user, script_name: request.script_name).call(message)
+          result ? render(json: result) : head(:accepted)
+        rescue JSON::ParserError
+          render json: { jsonrpc: "2.0", id: nil, error: { code: -32_700, message: "Parse error" } }, status: :bad_request
+        end
+
+        def unsupported
+          response.set_header("Allow", "POST")
+          head :method_not_allowed
+        end
+
+        private
+
+        def validate_transport!
+          origin = request.headers["Origin"]
+          if origin.present? && origin != request.base_url
+            head :forbidden
+            return
+          end
+          version = request.headers["MCP-Protocol-Version"]
+          if version.present? && Management::Mcp::VERSIONS.exclude?(version)
+            head :bad_request
+            return
+          end
+          return unless request.post?
+
+          unless request.media_type == "application/json"
+            head :unsupported_media_type
+            return
+          end
+          accept = request.headers["Accept"].to_s
+          head :not_acceptable unless accept.include?("application/json") && accept.include?("text/event-stream")
+        end
+      end
+    end
+  end
+end

data/app/controllers/postnhost/api_tokens_controller.rb

@@ -0,0 +1,34 @@
+module Postnhost
+  class ApiTokensController < ApplicationController
+    before_action :authenticate_user!
+    before_action :prevent_caching
+    layout "postnhost/product"
+
+    def index
+      @api_tokens = current_user.api_tokens.order(created_at: :desc)
+    end
+
+    def create
+      @api_token, @secret = ApiToken.issue!(user: current_user, **token_params.to_h.symbolize_keys)
+      @api_tokens = current_user.api_tokens.order(created_at: :desc)
+      render :index
+    rescue ActiveRecord::RecordInvalid => e
+      redirect_to api_tokens_path, alert: e.record.errors.full_messages.to_sentence
+    end
+
+    def destroy
+      current_user.api_tokens.find(params[:id]).revoke!
+      redirect_to api_tokens_path, notice: "API token revoked."
+    end
+
+    private
+
+    def prevent_caching
+      response.set_header("Cache-Control", "no-store")
+    end
+
+    def token_params
+      params.require(:api_token).permit(:name)
+    end
+  end
+end

data/app/controllers/postnhost/articles/translations_controller.rb

@@ -6,15 +6,8 @@ module Postnhost
     def new; end
 
     def create
-      language_ids = params[:language_ids] || []
-
-      language_ids.each do |language_id|
-        Postnhost::Translation::ArticleVariantJob.perform_later(@article.id, language_id.to_i)
-
-        @article.article_variants.create!(language: Postnhost::Language.find_by(id: language_id.to_i), generating: true)
-      end
-
-      redirect_to article_variants_path(@article)
+      result = Postnhost::Translation::Enqueue.call(record: @article, language_ids: Array(params[:language_ids]).map(&:to_i).uniq)
+      redirect_to article_variants_path(@article), **(result.success? ? {} : { alert: result.errors.to_sentence })
     end
 
     private

data/app/controllers/postnhost/categories/translations_controller.rb

@@ -4,15 +4,8 @@ module Postnhost
     before_action :load_category
 
     def create
-      language_ids = params[:language_ids] || []
-
-      language_ids.each do |language_id|
-        Postnhost::Translation::CategoryVariantJob.perform_later(@category.id, language_id.to_i)
-
-        @category.category_variants.create!(language: Postnhost::Language.find_by(id: language_id.to_i), generating: true)
-      end
-
-      redirect_to category_variants_path(@category)
+      result = Postnhost::Translation::Enqueue.call(record: @category, language_ids: Array(params[:language_ids]).map(&:to_i).uniq)
+      redirect_to category_variants_path(@category), **(result.success? ? {} : { alert: result.errors.to_sentence })
     end
 
     private

data/app/controllers/postnhost/management_preview_controller.rb

@@ -0,0 +1,17 @@
+module Postnhost
+  # Used only by Management::Preview for an authenticated in-process render.
+  # There are no routes to this controller.
+  class ManagementPreviewController < Public::ArticlesController
+    helper_method :postnhost
+
+    private
+
+    def postnhost
+      @postnhost ||= ActionDispatch::Routing::RoutesProxy.new(Engine.routes, self, Engine.routes.url_helpers)
+    end
+
+    def current_user
+      request.env.fetch("postnhost.management_user")
+    end
+  end
+end

data/app/controllers/postnhost/pages/translations_controller.rb

@@ -6,15 +6,8 @@ module Postnhost
     def new; end
 
     def create
-      language_ids = params[:language_ids] || []
-
-      language_ids.each do |language_id|
-        Postnhost::Translation::PageVariantJob.perform_later(@page.id, language_id.to_i)
-
-        @page.page_variants.create!(language: Postnhost::Language.find_by(id: language_id.to_i), generating: true)
-      end
-
-      redirect_to page_variants_path(@page)
+      result = Postnhost::Translation::Enqueue.call(record: @page, language_ids: Array(params[:language_ids]).map(&:to_i).uniq)
+      redirect_to page_variants_path(@page), **(result.success? ? {} : { alert: result.errors.to_sentence })
     end
 
     private

data/app/helpers/postnhost/application_helper.rb

@@ -13,17 +13,6 @@ module Postnhost
       { field: :bluesky_url, label: "Bluesky", icon: "bluesky" }
     ].freeze
 
-    def postnhost_stylesheet_assets
-      assets = ["postnhost/application"]
-      assets << "postnhost/host" if postnhost_host_tailwind_enabled?
-      assets
-    end
-
-    def postnhost_host_tailwind_enabled?
-      Rails.root.join("postnhost.tailwind.config.js").exist? &&
-        Rails.root.join("app/assets/stylesheets/postnhost/host.tailwind.css").exist?
-    end
-
     def postnhost_openai_api_key_configured?
       Postnhost.config.openai_api_key.present?
     end

data/app/models/postnhost/api_token.rb

@@ -0,0 +1,26 @@
+require "digest"
+require "securerandom"
+
+module Postnhost
+  class ApiToken < ApplicationRecord
+    belongs_to :user, class_name: "Postnhost::User"
+    validates :name, :token_digest, presence: true
+    validates :token_digest, uniqueness: true
+
+    def self.issue!(user:, name:)
+      secret = "pnh_#{SecureRandom.urlsafe_base64(32)}"
+      token = create!(user:, name:, token_digest: Digest::SHA256.hexdigest(secret))
+      [token, secret]
+    end
+
+    def self.authenticate(secret)
+      return if secret.blank?
+
+      find_by(token_digest: Digest::SHA256.hexdigest(secret), revoked_at: nil)
+    end
+
+    def revoke!
+      update!(revoked_at: Time.current)
+    end
+  end
+end

data/app/models/postnhost/user.rb

@@ -5,6 +5,8 @@ module Postnhost
 
     self.table_name = "postnhost_users"
 
+    has_many :api_tokens, class_name: "Postnhost::ApiToken", dependent: :destroy
+
     has_secure_password
 
     mount_uploader :avatar_file, Postnhost::AvatarUploader

data/app/services/postnhost/api/v1/openapi.rb

@@ -0,0 +1,27 @@
+module Postnhost
+  module Api
+    module V1
+      module Openapi
+        def self.document(server:)
+          { openapi: "3.1.0", info: { title: "PostnHost CMS management API", version: "1" }, servers: [{ url: server }],
+            security: [{ bearerAuth: [] }], components: { securitySchemes: { bearerAuth: { type: "http", scheme: "bearer" } } },
+            paths: Management::Catalog.tools.to_h { |tool| ["/commands/#{tool[:name]}", { post: operation(tool) }] } }
+        end
+
+        def self.operation(tool)
+          { operationId: tool[:name], summary: tool[:description],
+            requestBody: { required: true, content: { "application/json" => { schema: { type: "object", required: ["arguments"], properties: { arguments: tool[:inputSchema] } } } } },
+            responses: {
+              "200" => { description: "Command completed. JSON contains data and errors." },
+              "202" => { description: "Translation queued. Poll the variant's generating field." },
+              "400" => { description: "Invalid arguments." }, "401" => { description: "Invalid bearer token." },
+              "404" => { description: "Record not found in the requested scope." },
+              "409" => { description: "Conflicting data or protected action." },
+              "422" => { description: "Validation or publication failure. Bulk results contain per-record failures." },
+              "503" => { description: "Translation queue unavailable. Data identifies queued work and failed_language_ids to retry." }
+            } }
+        end
+      end
+    end
+  end
+end

data/app/services/postnhost/management/catalog.rb

@@ -0,0 +1,151 @@
+module Postnhost
+  module Management
+    module Catalog
+      INTEGER = { type: "integer", minimum: 1 }.freeze
+      IDS = { type: "array", items: INTEGER, minItems: 1, maxItems: 100, uniqueItems: true }.freeze
+      FILE = { type: "object", properties: { filename: { type: "string" }, content_type: { type: "string" }, base64: { type: "string" } }, required: %w[filename content_type base64], additionalProperties: false }.freeze
+      READ_ACTIONS = %w[list get versions version_preview preview get_navigation get_translations].freeze
+
+      def self.tools
+        @tools ||= freeze_schema(build_tools)
+      end
+
+      def self.build_tools
+        Resources::DEFINITIONS.flat_map do |resource, definition|
+          actions = definition[:singleton] ? %w[get update] : %w[list get create update delete]
+          actions.delete("update") if resource == "api_tokens"
+          actions += %w[publish unpublish] if %w[articles pages article_variants page_variants].include?(resource)
+          actions += %w[translate] if %w[articles pages categories].include?(resource)
+          actions += %w[bulk_publish bulk_unpublish bulk_delete] if %w[article_variants page_variants].include?(resource)
+          actions += %w[versions version_preview restore preview upload_image upload_cover remove_cover] if resource == "articles"
+          actions += %w[preview upload_image] if resource == "pages"
+          actions += %w[get_navigation replace_navigation get_translations update_translations upload_logo upload_og_image remove_logo remove_og_image] if resource == "settings"
+          actions += %w[preview] if resource == "template"
+          actions += %w[upload_avatar] if resource == "users"
+          actions.map { |action| tool(resource, action, definition) }
+        end
+      end
+
+      def self.fetch(name)
+        @tools_by_name ||= tools.index_by { |tool| tool[:name] }.freeze
+        @tools_by_name.fetch(name) { raise ArgumentError, "Unknown command: #{name}" }
+      end
+
+      def self.tool(resource, action, definition)
+        read = READ_ACTIONS.include?(action)
+        detail = if action == "list"
+                   "Returns compact summaries; use get for full content, relationships and draft comparisons."
+                 elsif read
+                   "Reads CMS draft data."
+                 else
+                   "Uses CMS validations and publication workflows."
+                 end
+        { name: "#{resource}_#{action}", description: "#{action.tr('_', ' ').capitalize} #{resource.tr('_', ' ')}. #{detail}",
+          inputSchema: schema(resource, action, definition),
+          annotations: { readOnlyHint: read, destructiveHint: !read, idempotentHint: read || %w[update unpublish delete].include?(action) || action.start_with?("remove_"), openWorldHint: action == "translate" } }
+      end
+
+      def self.schema(resource, action, definition)
+        properties = {}
+        required = []
+        if definition[:parent]
+          properties["parent_id"] = INTEGER
+          required << "parent_id"
+        end
+        unless definition[:singleton] || %w[list create translate].include?(action) || action.start_with?("bulk_")
+          properties["id"] = INTEGER
+          required << "id"
+        end
+        case action
+        when "list"
+          properties["page"] = INTEGER
+          properties["limit"] = { type: "integer", minimum: 1, maximum: 100 }
+          properties["language_id"] = INTEGER if definition[:fields].include?("language_id")
+          properties.merge!("status" => { type: "string", enum: Article::STATUSES }, "sort" => { type: "string", enum: Article::SORT_OPTIONS.keys }, "mine" => { type: "boolean" }, "category_id" => INTEGER, "user_id" => INTEGER) if resource == "articles"
+        when "preview"
+          properties["name"] = { type: "string", enum: Template::NAMES } if resource == "template"
+          required << "name" if resource == "template"
+        when "create", "update"
+          properties["attributes"] = { type: "object", properties: definition[:fields].index_with { |field| field_schema(field, resource) }, additionalProperties: false }
+          required << "attributes"
+        when "translate"
+          properties["id"] = INTEGER
+          properties["language_ids"] = IDS
+          required += %w[id language_ids]
+        when "bulk_publish", "bulk_unpublish", "bulk_delete"
+          properties["ids"] = IDS
+          required << "ids"
+        when "restore", "version_preview"
+          properties["version_id"] = INTEGER
+          required << "version_id"
+        when "replace_navigation"
+          properties["tree"] = { type: "object", properties: { header: { type: "array", items: navigation_item_schema, maxItems: 100 }, footer: { type: "array", items: navigation_item_schema, maxItems: 100 } }, required: %w[header footer], additionalProperties: false }
+          required << "tree"
+          properties["locale"] = { type: "string" }
+          required << "locale"
+        when "get_navigation", "get_translations", "update_translations"
+          properties["locale"] = { type: "string" }
+          required << "locale"
+          if action == "update_translations"
+            properties["translations"] = { type: "object", additionalProperties: { type: "string" } }
+            required << "translations"
+          end
+        else
+          if action.start_with?("upload_")
+            properties["file"] = FILE
+            required << "file"
+          end
+        end
+        { type: "object", properties:, required:, additionalProperties: false }
+      end
+
+      def self.navigation_item_schema(depth = 0)
+        properties = {
+          id: INTEGER, kind: { type: "string", enum: NavigationItem.kinds.keys },
+          target_kind: { type: %w[string null], enum: NavigationItem.target_kinds.keys + [nil] },
+          target_id: { type: %w[integer null] }, target_slug: { type: %w[string null] },
+          url: { type: %w[string null] }, label: { type: %w[string null] }, nofollow: { type: "boolean" }
+        }
+        properties[:children] = { type: "array", items: navigation_item_schema(depth + 1), maxItems: 100 } if depth < 2
+        { type: "object", properties:, required: ["kind"], additionalProperties: false }
+      end
+
+      # This module is reloadable: schemas and their name index disappear with it.
+      # Freeze nested values so one consumer cannot modify another client's contract.
+      def self.freeze_schema(value)
+        case value
+        when Hash then value.each do |key, child|
+          freeze_schema(key)
+          freeze_schema(child)
+        end
+        when Array then value.each { |child| freeze_schema(child) }
+        end
+        value.freeze
+      end
+      private_class_method :build_tools, :freeze_schema
+
+      def self.field_schema(field, resource)
+        return { type: "string", enum: Template::NAMES } if resource == "template" && field == "name"
+        return { type: "string", enum: SiteScript::PLACEMENTS } if field == "placement"
+
+        return { type: %w[string null], format: "date-time" } if field == "scheduled_at"
+
+        if field.end_with?("_ids")
+          { type: "array", items: INTEGER, maxItems: 100, uniqueItems: true }
+        elsif field.end_with?("_id") || field == "public_page_size"
+          { type: %w[integer null] }
+        elsif %w[default top_pick use_excerpt_as_meta_description author_pages_enabled search_enabled show_powered_by use_auto_header_navigation use_auto_footer_navigation].include?(field)
+          { type: "boolean" }
+        elsif field == "schema_settings"
+          SchemaFields.settings
+        elsif field == "schema_profile"
+          SchemaFields.profile
+        elsif field == "schema_locale_overrides"
+          SchemaFields.overrides(resource)
+        else
+          { type: %w[string null] }
+        end
+      end
+    end
+  end
+end

data/app/services/postnhost/management/command.rb

@@ -0,0 +1,174 @@
+module Postnhost
+  module Management
+    class Command < BaseService
+      def initialize(name:, arguments:, user:, script_name: "")
+        @name = name
+        @arguments = arguments.deep_stringify_keys
+        @user = user
+        @script_name = script_name
+      end
+
+      def call
+        return failure("Authentication required", status: :unauthorized) unless user
+
+        tool = Catalog.fetch(name)
+        Input.validate!(arguments, tool[:inputSchema])
+        resource = Resources::DEFINITIONS.keys.find { |key| name.start_with?("#{key}_") }
+        action = name.delete_prefix("#{resource}_")
+        result = PaperTrail.request(whodunnit: user.id.to_s) do
+          Time.use_zone(Setting.current.effective_timezone_name) { execute(resource, action) }
+        end
+        result.is_a?(ServiceResult) ? serialize_result(result) : success(Serializer.call(result), status: :ok)
+      rescue ActiveRecord::RecordNotFound
+        failure("Record not found", status: :not_found)
+      rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotDestroyed => e
+        failure(e.record.errors.full_messages)
+      rescue ActiveRecord::RecordNotUnique, ActiveRecord::InvalidForeignKey
+        failure("Record conflicts with existing or referenced data", status: :conflict)
+      rescue ActiveRecord::StaleObjectError
+        failure("Record changed; reload and retry", status: :conflict)
+      rescue ArgumentError, TypeError => e
+        failure(e.message, status: :bad_request)
+      end
+
+      private
+
+      attr_reader :name, :arguments, :user, :script_name
+
+      def serialize_result(result)
+        ServiceResult.new(value: Serializer.call(result.value), errors: result.errors, status: result.status || :ok)
+      end
+
+      def execute(resource, action)
+        definition = Resources::DEFINITIONS.fetch(resource)
+        scope = scope_for(resource, definition)
+        return list(scope, resource) if action == "list"
+        return create(scope, resource, definition) if action == "create"
+        return ContentActions.call(resource:, action:, scope:, arguments:) if action.start_with?("bulk_")
+
+        scope = scope.select(:id) if action == "versions"
+        record = definition[:singleton] ? Resources.model(resource).current : scope.find(arguments.fetch("id"))
+        case action
+        when "get" then record
+        when "update" then update(record)
+        when "delete" then delete(record)
+        when "preview"
+          if resource == "template"
+            Preview.call(user:, template: arguments.fetch("name"), script_name:)
+          elsif resource == "articles"
+            Preview.call(user:, record:, script_name:).merge(draft: record)
+          else
+            ContentActions.call(resource:, action:, scope:, record:, arguments:)
+          end
+        else ContentActions.call(resource:, action:, scope:, record:, arguments:)
+        end
+      end
+
+      def scope_for(resource, definition)
+        if definition[:parent]
+          parent = Resources.model(definition[:parent]).find(arguments.fetch("parent_id"))
+          parent.public_send(resource)
+        elsif resource == "api_tokens"
+          user.api_tokens
+        elsif resource == "site_scripts"
+          Setting.current.site_scripts
+        else
+          Resources.model(resource).all
+        end
+      end
+
+      def list(scope, resource)
+        scope = scope.where(language_id: arguments["language_id"]) if arguments["language_id"] && scope.klass.column_names.include?("language_id")
+        if resource == "articles"
+          scope = scope.where(user_id: user.id) if arguments["mine"]
+          scope = scope.joins(:article_categories).where(postnhost_article_categories: { category_id: arguments["category_id"] }) if arguments["category_id"]
+          scope = scope.where(user_id: arguments["user_id"]) if arguments["user_id"]
+          scope = scope.with_status(arguments["status"]).sorted_by(arguments["sort"])
+        else
+          scope = scope.order(:id)
+        end
+        limit = arguments.fetch("limit", 25)
+        page = arguments.fetch("page", 1)
+        records = summary_scope(scope, resource).limit(limit).offset((page - 1) * limit)
+        result = { records: records.map { |record| Serializer.summary(record) }, total: scope.count, page:, limit: }
+        result[:static_pages] = static_page_slugs if resource == "pages"
+        result
+      end
+
+      def summary_scope(scope, resource)
+        table = scope.klass.arel_table
+        fields = Serializer::SUMMARY_FIELDS & scope.klass.column_names
+        records = scope.select(*fields.map { |field| table[field] })
+        snapshot = Resources::DEFINITIONS.fetch(resource)[:snapshot]
+        return records unless snapshot
+
+        association = scope.klass.reflect_on_association(snapshot)
+        snapshot_table = association.klass.arel_table
+        snapshot_id = association.klass.where(snapshot_table[association.foreign_key].eq(table[:id])).select(:id).limit(1)
+        records.select(snapshot_id.arel.as("management_snapshot_id"))
+      end
+
+      def static_page_slugs
+        [Rails.root, Engine.root].flat_map { |root| Dir[root.join("app/views/postnhost/static_pages/*.html.erb").to_s] }
+                                 .map { |path| File.basename(path, ".html.erb") }.uniq.sort
+      end
+
+      def create(scope, resource, definition)
+        attrs = arguments.fetch("attributes")
+        if resource == "api_tokens"
+          token, secret = ApiToken.issue!(user:, **attrs.symbolize_keys)
+          return { token:, secret: }
+        end
+        if %w[articles pages].include?(resource)
+          attrs = { "language_id" => Language.blog_default&.id }.merge(attrs).merge("user_id" => user.id)
+        elsif definition[:parent] && resource != "category_variants"
+          parent = Resources.model(definition[:parent]).find(arguments.fetch("parent_id"))
+          copied = parent.attributes.slice(*definition[:fields]).except("language_id")
+          attrs = copied.merge(attrs)
+        end
+        validate_schema_locales!(attrs)
+        record = scope.create!(attrs)
+        record.sync_publication_schedule! if record.is_a?(Article)
+        record
+      end
+
+      def update(record)
+        raise ArgumentError, "Translation is still generating" if record.respond_to?(:generating?) && record.generating?
+
+        attrs = arguments.fetch("attributes")
+        attrs = attrs.except("password", "password_confirmation") if record.is_a?(User) && attrs["password"].blank?
+        validate_schema_locales!(attrs)
+        record.update!(attrs)
+        record.sync_publication_schedule! if record.is_a?(Article)
+        record
+      end
+
+      def validate_schema_locales!(attributes)
+        return unless attributes["schema_locale_overrides"]
+
+        unknown = attributes["schema_locale_overrides"].keys - Language.pluck(:html_lang)
+        raise ArgumentError, "Schema locales must belong to configured languages" if unknown.any?
+      end
+
+      def delete(record)
+        if record.is_a?(ApiToken)
+          record.revoke!
+          return { revoked: true, id: record.id }
+        end
+        if record.is_a?(User)
+          return failure("You cannot remove your own account", status: :conflict) if record == user
+          return failure("Author owns pages; reassign or remove them first", status: :conflict) if record.pages.exists?
+
+          User.transaction do
+            Article.where(user_id: record.id).update_all(user_id: nil, updated_at: Time.current)
+            record.article_authors.delete_all
+            record.destroy!
+          end
+        else
+          record.destroy!
+        end
+        { deleted: true, id: record.id }
+      end
+    end
+  end
+end

data/app/services/postnhost/management/content_actions.rb

@@ -0,0 +1,75 @@
+module Postnhost
+  module Management
+    class ContentActions < BaseService
+      def initialize(resource:, action:, scope:, arguments:, record: nil)
+        @resource = resource
+        @action = action
+        @scope = scope
+        @arguments = arguments
+        @record = record
+      end
+
+      def call
+        case action
+        when "publish", "unpublish" then transition
+        when "bulk_publish", "bulk_unpublish" then bulk_transition
+        when "bulk_delete" then bulk_delete
+        when "translate" then Translation::Enqueue.call(record:, language_ids: arguments.fetch("language_ids"))
+        when "versions" then versions
+        when "version_preview" then record.versions.find(arguments.fetch("version_id")).reify
+        when "restore" then Publishing::Versions::RestoreDraft.call(record:, version: record.versions.find(arguments.fetch("version_id")))
+        when "preview" then { draft: record, html: record.content }
+        when "remove_cover"
+          record.update_column(:cover_image, nil)
+          record.reload
+        else
+          SettingsActions.call(action:, record:, arguments:)
+        end
+      end
+
+      private
+
+      attr_reader :resource, :action, :scope, :arguments, :record
+
+      def versions
+        columns = record.versions.klass.column_names - ["object"]
+        record.versions.select(*columns).order(id: :desc).map(&:attributes)
+      end
+
+      def transition
+        return failure("Translation is still generating", status: :conflict) if record.respond_to?(:generating?) && record.generating?
+
+        service = publishing_module.const_get(action.classify, false)
+        result = service.call(resource.singularize.to_sym => record)
+        result.success? ? success(record.reload, status: result.status) : result
+      end
+
+      def bulk_transition
+        parent_resource = Resources::DEFINITIONS.fetch(resource).fetch(:parent)
+        parent = Resources.model(parent_resource).find(arguments.fetch("parent_id"))
+        service = publishing_module.const_get("#{action.delete_prefix('bulk_').classify}Many", false)
+        service.call(parent_resource.singularize.to_sym => parent, ids: arguments.fetch("ids"))
+      end
+
+      def publishing_module
+        Publishing.const_get(resource.camelize, false)
+      end
+
+      def bulk_delete
+        records = scope.where(id: arguments.fetch("ids")).order(:id)
+        failures = (arguments.fetch("ids") - records.pluck(:id)).index_with { ["Translation not found"] }
+        deleted = []
+        records.each do |variant|
+          if variant.generating?
+            failures[variant.id] = ["Translation is still generating"]
+          elsif variant.destroy
+            deleted << variant.id
+          else
+            failures[variant.id] = variant.errors.full_messages
+          end
+        end
+        success({ deleted:, failures: }, status: failures.empty? ? :ok : :unprocessable_content)
+      end
+    end
+  end
+end