cms42 0.1.0

data/app/models/cms/section.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Cms
+  class Section < ApplicationRecord
+    include ::Discard::Model
+
+    self.table_name = "cms_sections"
+
+    attribute :settings, default: -> { {} }
+    store_accessor :settings, :background_color, :cta_url, :button_url, :alignment
+
+    belongs_to :site,
+               class_name: "Cms::Site",
+               inverse_of: :sections
+
+    has_many :page_sections,
+             class_name: "Cms::PageSection",
+             foreign_key: :section_id,
+             inverse_of: :section,
+             dependent: :destroy
+
+    has_many :pages,
+             through: :page_sections,
+             source: :page
+
+    has_many :translations,
+             class_name: "Cms::SectionTranslation",
+             foreign_key: :section_id,
+             inverse_of: :section,
+             dependent: :destroy
+
+    has_one :localised, -> { where(locale: I18n.locale.to_s) },
+            class_name: "Cms::SectionTranslation",
+            foreign_key: :section_id,
+            inverse_of: :section
+
+    has_many :section_images,
+             -> { order(:position) },
+             class_name: "Cms::SectionImage",
+             foreign_key: :section_id,
+             inverse_of: :section,
+             dependent: :destroy
+
+    has_many :images,
+             through: :section_images,
+             source: :image,
+             class_name: "Cms::Image"
+
+    accepts_nested_attributes_for :translations
+
+    validates :kind, presence: true, inclusion: { in: -> { Cms::Section::KindRegistry.registered_kinds } }
+    validates :alignment, inclusion: { in: %w[left center right] }, allow_blank: true
+
+    scope :ordered,  -> { order(:kind, :id) }
+    scope :enabled,  -> { where(enabled: true) }
+    scope :global,   -> { where(global: true) }
+    scope :local,    -> { where(global: false) }
+    scope :by_kind,  ->(kind) { where(kind: kind) }
+
+    delegate :title, :subtitle, :content, to: :localised, allow_nil: true
+
+    def cta_text    = localised&.subtitle
+    def button_text = localised&.subtitle
+
+    def build_missing_locale_translations
+      present = if translations.loaded?
+                  translations.target.map(&:locale)
+                elsif new_record?
+                  []
+                else
+                  translations.pluck(:locale)
+                end
+      I18n.available_locales.map(&:to_s).each do |locale|
+        translations.build(locale: locale) unless present.include?(locale)
+      end
+    end
+
+    def image_assets
+      images.includes(file_attachment: :blob)
+    end
+
+    def available_locales
+      translations.map(&:locale)
+    end
+
+    def translation_for(locale)
+      translations.find { |t| t.locale == locale.to_s }
+    end
+
+    def settings
+      super || {}
+    end
+  end
+end

data/app/models/cms/section_image.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cms
+  class SectionImage < ApplicationRecord
+    self.table_name = "cms_section_images"
+
+    belongs_to :section, class_name: "Cms::Section", inverse_of: :section_images
+    belongs_to :image,   class_name: "Cms::Image"
+  end
+end

data/app/models/cms/section_translation.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Cms
+  class SectionTranslation < ApplicationRecord
+    self.table_name = "cms_section_translations"
+
+    has_rich_text :content
+
+    belongs_to :section,
+               class_name: "Cms::Section",
+               inverse_of: :translations
+
+    validates :locale, :title, presence: true
+    validates :locale, uniqueness: { scope: :section_id }
+    validates :content, presence: true, if: -> { section&.kind.in?(%w[rich_text hero cta]) }
+
+    before_validation :normalize_locale
+
+    private
+
+    def normalize_locale
+      self.locale = locale.to_s.downcase.presence
+    end
+  end
+end

data/app/models/cms/site.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Cms
+  class Site < ApplicationRecord
+    self.table_name = "cms_sites"
+
+    has_one_attached :logo
+
+    has_many :pages,
+             class_name: "Cms::Page",
+             foreign_key: :site_id,
+             inverse_of: :site,
+             dependent: :destroy
+
+    has_many :images,
+             class_name: "Cms::Image",
+             foreign_key: :site_id,
+             inverse_of: :site,
+             dependent: :destroy
+
+    has_many :documents,
+             class_name: "Cms::Document",
+             foreign_key: :site_id,
+             inverse_of: :site,
+             dependent: :destroy
+
+    has_many :sections,
+             class_name: "Cms::Section",
+             foreign_key: :site_id,
+             inverse_of: :site,
+             dependent: :destroy
+
+    has_many :api_keys,
+             class_name: "Cms::ApiKey",
+             foreign_key: :site_id,
+             inverse_of: :site,
+             dependent: :destroy
+
+    has_many :webhooks,
+             class_name: "Cms::Webhook",
+             foreign_key: :site_id,
+             inverse_of: :site,
+             dependent: :destroy
+
+    validates :name, :slug, :default_locale, presence: true
+    validates :slug, uniqueness: true
+    validate :default_locale_is_available
+
+    before_validation :parameterize_slug
+    before_validation :normalize_locales
+
+    scope :live, -> { where(published: true) }
+
+    def published_pages
+      pages.kept.published.ordered
+    end
+
+    def header_pages
+      published_pages.header_nav
+    end
+
+    def footer_pages
+      published_pages.footer_nav
+    end
+
+    def home_page
+      published_pages.find_by(home: true) || published_pages.first
+    end
+
+    private
+
+    def parameterize_slug
+      self.slug = slug.to_s.parameterize if slug.present?
+    end
+
+    def normalize_locales
+      self[:default_locale] = self[:default_locale].to_s.presence || I18n.default_locale.to_s
+    end
+
+    def default_locale_is_available
+      supported = I18n.available_locales.map(&:to_s)
+      return if supported.include?(self[:default_locale].to_s)
+
+      errors.add(:default_locale, I18n.t("cms.errors.site.default_locale_unavailable"))
+    end
+  end
+end

data/app/models/cms/webhook.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Cms
+  class Webhook < ApplicationRecord
+    self.table_name = "cms_webhooks"
+
+    EVENTS = %w[page.published page.unpublished].freeze
+
+    belongs_to :site, class_name: "Cms::Site", inverse_of: :webhooks
+
+    has_many :deliveries,
+             class_name: "Cms::WebhookDelivery",
+             foreign_key: :webhook_id,
+             inverse_of: :webhook,
+             dependent: :destroy
+
+    validates :url, presence: true, format: { with: URI::DEFAULT_PARSER.make_regexp(%w[http https]) }
+    validates :events, presence: true
+    validate :events_must_be_supported
+
+    scope :active, -> { where(active: true) }
+    scope :ordered, -> { order(:url) }
+
+    before_validation :normalize_events
+
+    private
+
+    def normalize_events
+      self.events = Array(events).map(&:to_s).reject(&:blank?).uniq
+    end
+
+    def events_must_be_supported
+      return if events.blank?
+
+      invalid_events = events - EVENTS
+      return if invalid_events.empty?
+
+      errors.add(:events, I18n.t("cms.errors.webhook.unsupported_events", events: invalid_events.join(", ")))
+    end
+  end
+end

data/app/models/cms/webhook_delivery.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Cms
+  class WebhookDelivery < ApplicationRecord
+    self.table_name = "cms_webhook_deliveries"
+
+    belongs_to :webhook, class_name: "Cms::Webhook", inverse_of: :deliveries
+
+    scope :ordered, -> { order(delivered_at: :desc) }
+    scope :recent,  -> { ordered.limit(50) }
+  end
+end

data/app/serializers/cms/api/base_serializer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Cms
+  module Api
+    class BaseSerializer
+      def initialize(site:, requested_locale:, main_app:)
+        @site = site
+        @requested_locale = requested_locale
+        @main_app = main_app
+      end
+
+      private
+
+      attr_reader :site, :requested_locale, :main_app
+
+      def resolved_content_locale(available_locales)
+        Cms::LocaleResolver.resolve(
+          requested: requested_locale,
+          site: site,
+          available: available_locales
+        )
+      end
+
+      def attachment_path(attachment)
+        return nil unless attachment.attached?
+
+        main_app.rails_blob_path(attachment, only_path: true)
+      end
+
+      def serialize_media(file)
+        {
+          filename: file.filename.to_s,
+          url: attachment_path(file)
+        }
+      end
+
+      def site_attributes(resolved_locale:)
+        {
+          id: site.id,
+          name: site.name,
+          slug: site.slug,
+          default_locale: site.default_locale,
+          resolved_locale: resolved_locale,
+          available_locales: I18n.available_locales.map(&:to_s),
+          logo_url: attachment_path(site.logo),
+          favicon_url: attachment_path(site.logo)
+        }
+      end
+    end
+  end
+end

data/app/serializers/cms/api/page_serializer.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Cms
+  module Api
+    class PageSerializer < BaseSerializer
+      def initialize(site:, page:, requested_locale:, main_app:)
+        super(site: site, requested_locale: requested_locale, main_app: main_app)
+        @page = page
+      end
+
+      def as_json(include_site: false)
+        payload = serialize_page
+        return payload unless include_site
+
+        payload.merge(
+          site: Cms.api_site_serializer_class.new(
+            site: site,
+            requested_locale: payload[:resolved_locale],
+            main_app: main_app
+          ).as_json(include_pages: false)
+        )
+      end
+
+      private
+
+      attr_reader :page
+
+      def serialize_page
+        locale = resolved_content_locale(page.page_translations.map(&:locale))
+        translation = page.page_translations.find { |record| record.locale == locale }
+
+        base_page_attributes(locale, translation).merge(
+          meta_title: page_meta_title(translation),
+          meta_description: translation&.seo_description,
+          media_files: page.media_files.map { |file| serialize_media(file) },
+          sections: serialize_page_sections(locale)
+        )
+      end
+
+      def serialize_page_sections(locale)
+        page.page_sections.ordered.includes(:section).filter_map do |page_section|
+          section = page_section.section
+          next unless section.enabled?
+
+          serialize_section(section, position: page_section.position, requested_locale: locale)
+        end
+      end
+
+      def serialize_section(section, position:, requested_locale:)
+        locale = resolved_content_locale_for_section(section, requested_locale)
+        translation = section.translation_for(locale)
+
+        {
+          id: section.id,
+          kind: section.kind,
+          position: position,
+          resolved_locale: locale,
+          available_locales: section.available_locales,
+          title: translation.respond_to?(:title) ? translation.title : nil,
+          body: translation.respond_to?(:content) ? translation.content.to_s : "",
+          settings: {},
+          data: serialize_section_data(section, requested_locale: locale)
+        }
+      end
+
+      def resolved_content_locale_for_section(section, requested_locale)
+        available_locales = section.available_locales
+        if available_locales.empty? && section.kind == "image"
+          available_locales = section.images.flat_map { |image| image.image_translations.map(&:locale) }.uniq
+        end
+
+        Cms::LocaleResolver.resolve(
+          requested: requested_locale,
+          site: site,
+          available: available_locales
+        )
+      end
+
+      def serialize_section_data(section, requested_locale:)
+        case section.kind
+        when "hero"
+          {
+            background_color: section.background_color,
+            cta_text: section.translation_for(requested_locale)&.subtitle,
+            cta_url: section.cta_url
+          }
+        when "cta"
+          {
+            button_text: section.translation_for(requested_locale)&.subtitle,
+            button_url: section.button_url,
+            alignment: section.alignment.presence || "center"
+          }
+        when "image"
+          image_payloads = serialize_section_images(section, requested_locale)
+          {
+            images: image_payloads
+          }
+        else
+          {}
+        end
+      end
+
+      def serialize_section_images(section, requested_locale)
+        section.image_assets.filter_map do |image|
+          locale = Cms::LocaleResolver.resolve(
+            requested: requested_locale,
+            site: site,
+            available: image.image_translations.map(&:locale)
+          )
+          translation = image.image_translations.find { |record| record.locale == locale }
+
+          {
+            id: image.id,
+            title: image.title,
+            alt_text: translation&.alt_text,
+            caption: translation&.caption,
+            url: attachment_path(image.file)
+          }
+        end
+      end
+
+      def base_page_attributes(locale, translation)
+        {
+          id: page.id,
+          template_key: page.template_key,
+          status: page.status,
+          resolved_locale: locale,
+          available_locales: page.page_translations.map(&:locale),
+          title: translation_title(translation),
+          slug: page.slug,
+          path: page.public_path,
+          hero_image_url: attachment_path(page.hero_image)
+        }
+      end
+
+      def translation_title(translation)
+        translation&.title.presence || page.slug.to_s.humanize
+      end
+
+      def page_meta_title(translation)
+        translation&.seo_title.presence || translation_title(translation)
+      end
+    end
+  end
+end

data/app/serializers/cms/api/site_serializer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Cms
+  module Api
+    class SiteSerializer < BaseSerializer
+      def as_json(include_pages: true)
+        payload = site_attributes(resolved_locale: requested_locale)
+        return payload unless include_pages
+
+        payload.merge(
+          pages: published_pages.map do |page|
+            serialize_site_page(page)
+          end
+        )
+      end
+
+      private
+
+      def published_pages
+        site.published_pages.includes(:page_translations, { hero_image_attachment: :blob })
+      end
+
+      def serialize_site_page(page)
+        locale = resolved_content_locale(page.page_translations.map(&:locale))
+        translation = page.page_translations.find { |record| record.locale == locale }
+
+        {
+          id: page.id,
+          template_key: page.template_key,
+          status: page.status,
+          resolved_locale: locale,
+          available_locales: page.page_translations.map(&:locale),
+          title: translation&.title.presence || page.slug.to_s.humanize,
+          slug: page.slug,
+          path: page.public_path,
+          home: page.home,
+          nav_group: page.nav_group,
+          show_in_header: page.show_in_header,
+          show_in_footer: page.show_in_footer,
+          hero_image_url: attachment_path(page.hero_image)
+        }
+      end
+    end
+  end
+end

data/app/services/cms/locale_resolver.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Cms
+  # Resolves the best available locale given a preference and a set of available locales.
+  #
+  # Fallback chain: requested → site default → I18n default → first available
+  class LocaleResolver
+    def self.resolve(requested:, site:, available:)
+      new(requested: requested, site: site, available: available).resolve
+    end
+
+    def initialize(requested:, site:, available:)
+      @requested = requested.to_s.presence
+      @site      = site
+      @available = Array(available).map(&:to_s)
+    end
+
+    def resolve
+      return fallback_chain.first if @available.empty?
+
+      fallback_chain.find { |locale| @available.include?(locale) } || @available.first
+    end
+
+    private
+
+    def fallback_chain
+      [@requested, @site.default_locale, I18n.default_locale.to_s].compact.uniq
+    end
+  end
+end

data/app/services/cms/page_resolver.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Cms
+  class PageResolver
+    Result = Struct.new(:page, :locale)
+
+    # Finds a published page by slug within a site and resolves the best
+    # available locale using the fallback chain:
+    #   requested locale → site.default_locale → I18n.default_locale → any
+    #
+    # @param site [Cms::Site]
+    # @param slug [String, nil] nil or blank resolves the home page; nested
+    #   paths such as "about/history" resolve by ancestor chain
+    # @param locale [String, nil] the caller's preferred locale
+    # @return [Result, nil]
+    def self.resolve(site:, slug: nil, locale: nil)
+      new(site: site, slug: slug, locale: locale).resolve
+    end
+
+    def initialize(site:, slug:, locale:)
+      @site   = site
+      @slug   = slug.to_s
+      @locale = locale.to_s.presence
+    end
+
+    def resolve
+      page = find_page
+      return nil unless page
+
+      Result.new(page: page, locale: resolved_locale_for(page))
+    end
+
+    private
+
+    attr_reader :site, :slug, :locale
+
+    def normalized_segments
+      @normalized_segments ||= slug.to_s.split("/").filter_map do |segment|
+        normalized = segment.to_s.parameterize
+        normalized if normalized.present?
+      end
+    end
+
+    def find_page
+      scope = site.published_pages
+                  .includes(
+                    :page_translations,
+                    :localised,
+                    { page_sections: :section },
+                    :form_fields,
+                    { hero_image_attachment: :blob }
+                  )
+
+      if normalized_segments.empty?
+        scope.find_by(home: true) || scope.first
+      else
+        page = scope.find_by(slug: normalized_segments.last)
+        return unless page
+        return page if page.public_path_segments == normalized_segments
+
+        nil
+      end
+    end
+
+    def resolved_locale_for(page)
+      Cms::LocaleResolver.resolve(
+        requested: @locale,
+        site: @site,
+        available: page.page_translations.map(&:locale)
+      )
+    end
+  end
+end

data/app/services/cms/public_page_context.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Cms
+  class PublicPageContext
+    attr_reader :site, :page, :header_nav_items, :footer_pages, :sections, :form_fields, :submission
+
+    def self.build(site:, page:)
+      new(site: site, page: page).tap(&:load)
+    end
+
+    def initialize(site:, page:)
+      @site = site
+      @page = page
+    end
+
+    def load
+      @header_nav_items = load_header_nav
+      @footer_pages     = site.footer_pages.includes(:localised)
+      @sections         = load_sections
+      @form_fields      = page.form_fields.ordered.to_a
+      @submission       = page.form_submissions.build
+    end
+
+    private
+
+    def load_sections
+      page.page_sections
+          .ordered
+          .includes(:section)
+          .filter_map do |page_section|
+            section = page_section.section
+            section if section.enabled? && section.kept?
+          end
+    end
+
+    def load_header_nav
+      site.published_pages
+          .root
+          .header_nav
+          .includes(:localised, subpages: :localised)
+          .map do |p|
+            {
+              page: p,
+              children: p.subpages.select { |subpage| subpage.status_published? && subpage.show_in_header? }
+            }
+          end
+    end
+  end
+end

data/app/views/cms/admin/api_keys/_form.html.erb

@@ -0,0 +1,23 @@
+<%= form_with model: [:admin, api_key] do |f| %>
+  <% if api_key.errors.any? %>
+    <div>
+      <% api_key.errors.full_messages.each do |msg| %>
+        <p><%= msg %></p>
+      <% end %>
+    </div>
+  <% end %>
+
+  <div>
+    <%= f.label :name %>
+    <%= f.text_field :name %>
+  </div>
+
+  <div>
+    <%= f.label :active %>
+    <%= f.check_box :active %>
+  </div>
+
+  <div>
+    <%= f.submit %>
+  </div>
+<% end %>