postnhost 0.1.1 → 0.2.1

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

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

@@ -0,0 +1,49 @@
+module Postnhost
+  module Management
+    module Input
+      TYPES = {
+        "object" => [Hash],
+        "array" => [Array],
+        "integer" => [Integer],
+        "string" => [String],
+        "boolean" => [TrueClass, FalseClass],
+        "null" => [NilClass]
+      }.freeze
+
+      def self.validate!(value, schema, path = "arguments")
+        valid = Array(schema[:type]).any? do |type|
+          TYPES.fetch(type).any? { |klass| value.is_a?(klass) }
+        end
+        raise ArgumentError, "#{path} has an invalid type" unless valid
+
+        Time.iso8601(value) if schema[:format] == "date-time" && value
+
+        case value
+        when Hash
+          validate_object!(value, schema, path)
+        when Array
+          raise ArgumentError, "#{path} has an invalid length" if value.size < schema.fetch(:minItems, 0) || value.size > schema.fetch(:maxItems, 1000)
+          raise ArgumentError, "#{path} must contain unique values" if schema[:uniqueItems] && value.uniq != value
+
+          value.each { |item| validate!(item, schema[:items], path) } if schema[:items]
+        when Integer
+          raise ArgumentError, "#{path} is out of range" if value < schema.fetch(:minimum, value) || value > schema.fetch(:maximum, value)
+        end
+      end
+
+      def self.validate_object!(value, schema, path)
+        properties = schema.fetch(:properties, {}).stringify_keys
+        missing = schema.fetch(:required, []) - value.keys
+        raise ArgumentError, "#{path} requires #{missing.join(', ')}" if missing.any?
+
+        unknown = value.keys - properties.keys
+        raise ArgumentError, "#{path} contains unknown fields: #{unknown.join(', ')}" if schema[:additionalProperties] == false && unknown.any?
+
+        value.each do |key, item|
+          child = properties[key] || schema[:additionalProperties]
+          validate!(item, child, "#{path}.#{key}") if child.is_a?(Hash)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Postnhost
+  module Management
+    class Mcp
+      VERSIONS = %w[2025-11-25 2025-06-18 2025-03-26].freeze
+
+      def initialize(user:, script_name: "")
+        @user = user
+        @script_name = script_name
+      end
+
+      def call(message)
+        return error(nil, -32_600, "Invalid Request") unless message.is_a?(Hash)
+
+        id = message["id"]
+        return error(nil, -32_600, "Invalid Request") unless message["jsonrpc"] == "2.0" && message["method"].is_a?(String) && (!message.key?("id") || id.is_a?(String) || id.is_a?(Integer))
+        return nil unless message.key?("id")
+
+        params = message.fetch("params", {})
+        return error(id, -32_602, "params must be an object") unless params.is_a?(Hash)
+
+        result = case message["method"]
+                 when "initialize"
+                   { protocolVersion: VERSIONS.include?(params["protocolVersion"]) ? params["protocolVersion"] : VERSIONS.first,
+                     capabilities: { tools: { listChanged: false } }, serverInfo: { name: "PostnHost", version: Postnhost::VERSION },
+                     instructions: "Manage CMS drafts, translations and settings. Publishing is explicit. Generate translations from published sources. Files use base64 and follow the same upload limits as the CMS." }
+                 when "ping" then {}
+                 when "tools/list" then { tools: Catalog.tools }
+                 when "tools/call" then call_tool(params)
+                 else return error(id, -32_601, "Method not found")
+                 end
+        { jsonrpc: "2.0", id:, result: }
+      rescue ArgumentError => e
+        error(id, -32_602, e.message)
+      end
+
+      private
+
+      def call_tool(params)
+        name = params.fetch("name", "")
+        Catalog.fetch(name)
+        arguments = params.fetch("arguments", {})
+        raise ArgumentError, "arguments must be an object" unless arguments.is_a?(Hash)
+
+        result = Command.call(name:, arguments:, user: @user, script_name: @script_name)
+        data = { data: result.value, errors: result.errors, status: Rack::Utils.status_code(result.status) }
+        { content: [{ type: "text", text: data.to_json }], structuredContent: data, isError: !result.success? || data[:status] >= 400 }
+      end
+
+      def error(id, code, message)
+        { jsonrpc: "2.0", id:, error: { code:, message: } }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Postnhost
+  module Management
+    module Preview
+      def self.call(user:, record: nil, template: nil, script_name: "")
+        action = record ? "preview" : "index"
+        path = record ? "/preview/#{record.id}" : "/?preview_template=#{template}"
+        origin = Setting.current.effective_site_url || "http://example.com"
+        env = Rack::MockRequest.env_for("#{origin}#{script_name}#{path}")
+        env["SCRIPT_NAME"] = script_name
+        env["PATH_INFO"] = path.split("?").first
+        env["postnhost.management_user"] = user
+        env["action_dispatch.request.path_parameters"] = { controller: "postnhost/management_preview", action:, id: record&.id }
+        env["action_dispatch.routes"] = Engine.routes
+        status, _headers, body = I18n.with_locale(I18n.default_locale) { ManagementPreviewController.action(action).call(env) }
+        html = +""
+        body.each { |chunk| html << chunk }
+        raise ArgumentError, "Preview could not be rendered" unless status == 200
+
+        { html:, template: template || Template.active_name }
+      ensure
+        body&.close if body.respond_to?(:close)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Postnhost
+  module Management
+    module Resources
+      TEXT = %w[title title_tag og_title meta_description content language_id].freeze
+      EXCERPT = %w[custom_excerpt use_excerpt_as_meta_description].freeze
+      ARTICLE = (TEXT + EXCERPT + %w[schema_headline schema_article_type slug cover_image_alt scheduled_at top_pick author_ids category_ids suggested_article_ids]).freeze
+      PAGE = (TEXT + %w[slug]).freeze
+      USER = %w[email name slug position bio website_url x_url linkedin_url threads_url tiktok_url youtube_url facebook_url instagram_url bluesky_url mastodon_url password password_confirmation].freeze
+      SETTING = %w[site_url site_indexing public_page_size timezone author_pages_enabled search_enabled show_powered_by use_auto_header_navigation use_auto_footer_navigation schema_settings schema_locale_overrides].freeze
+      DEFINITIONS = {
+        "api_tokens" => { model: "ApiToken", fields: %w[name] },
+        "articles" => { model: "Article", fields: ARTICLE, snapshot: :article_snapshot },
+        "pages" => { model: "Page", fields: PAGE, snapshot: :page_snapshot },
+        "categories" => { model: "Category", fields: %w[name slug meta_description] },
+        "languages" => { model: "Language", fields: %w[name html_lang default] },
+        "users" => { model: "User", fields: USER + %w[schema_profile schema_locale_overrides] },
+        "article_variants" => { model: "ArticleVariant", fields: TEXT + EXCERPT + %w[schema_headline], parent: "articles", snapshot: :article_variant_snapshot },
+        "page_variants" => { model: "PageVariant", fields: TEXT, parent: "pages", snapshot: :page_variant_snapshot },
+        "category_variants" => { model: "CategoryVariant", fields: %w[name meta_description language_id], parent: "categories" },
+        "settings" => { model: "Setting", fields: SETTING, singleton: true },
+        "template" => { model: "Template", fields: %w[name], singleton: true },
+        "site_scripts" => { model: "SiteScript", fields: %w[placement script] }
+      }.freeze
+
+      def self.model(resource)
+        Postnhost.const_get(DEFINITIONS.fetch(resource).fetch(:model), false)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Postnhost
+  module Management
+    module SchemaFields
+      TEXT = { type: %w[string null] }.freeze
+      STRINGS = { type: "array", items: { type: "string" }, maxItems: 100 }.freeze
+
+      def self.settings
+        fields = Postnhost::Settings::SchemaManageable::SCHEMA_SETTING_FIELDS.index_with { TEXT }
+        fields["same_as"] = STRINGS
+        fields["policies"] = { type: "object", properties: Postnhost::SchemaHelper::POLICY_FIELDS.keys.index_with { TEXT }, additionalProperties: false }
+        { type: "object", properties: fields, additionalProperties: false }
+      end
+
+      def self.profile
+        fields = Postnhost::Users::SchemaManageable::USER_SCHEMA_PROFILE_FIELDS.index_with { |field| %w[same_as knows_language].include?(field) ? STRINGS : TEXT }
+        { type: "object", properties: fields, additionalProperties: false }
+      end
+
+      def self.overrides(resource)
+        fields = resource == "users" ? Postnhost::Users::SchemaManageable::USER_SCHEMA_TEXT_FIELDS : Postnhost::SchemaHelper::SETTINGS_TEXT_OVERRIDE_FIELDS
+        { type: "object", additionalProperties: { type: "object", properties: fields.index_with { TEXT }, additionalProperties: false } }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Postnhost
+  module Management
+    module Serializer
+      SUMMARY_FIELDS = %w[
+        id user_id article_id page_id category_id language_id name title slug email position
+        html_lang default created_at updated_at scheduled_at publication_error top_pick generating
+        articles_count article_variants_count page_variants_count placement revoked_at
+        cover_image cover_image_alt avatar_file
+      ].freeze
+
+      def self.summary(record)
+        data = record.attributes.slice(*SUMMARY_FIELDS)
+        data["published"] = record["management_snapshot_id"].present? if record.has_attribute?("management_snapshot_id")
+        %w[cover_image avatar_file].each do |field|
+          data["#{field}_url"] = record.public_send(field).url if record.has_attribute?(field)
+        end
+        data
+      end
+
+      def self.call(value)
+        case value
+        when ActiveRecord::Base
+          data = value.attributes.except("password_digest", "token_digest", "scheduled_job_id")
+          if value.respond_to?(:published?)
+            data["published"] = value.published?
+            data["unpublished_changes"] = value.unpublished_changes?
+          end
+          data.merge!("author_ids" => value.author_ids, "category_ids" => value.category_ids, "suggested_article_ids" => value.suggested_article_ids) if value.is_a?(Article)
+          %w[cover_image avatar_file site_logo og_image].each do |field|
+            data["#{field}_url"] = value.public_send(field).url if value.respond_to?(field)
+          end
+          data
+        when Hash then value.transform_values { |item| call(item) }
+        when Array then value.map { |item| call(item) }
+        else value
+        end
+      end
+    end
+  end
+end