plum-cms 0.2.0 → 0.2.2

data/app/javascript/controllers/plum/write_controller.js

@@ -0,0 +1,174 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Distraction-free writing mode: autosaves the title and one rich text field
+// a moment after typing stops, without leaving the page.
+export default class extends Controller {
+  static targets = ["form", "title", "editor", "status", "statusText", "words", "bar"]
+  static values = { publishUrl: String }
+
+  connect() {
+    this.dirty = false
+    this.saving = false
+    this.resizeTitle()
+    this.refreshWordCount()
+
+    // Lexical swallows native input events, so "input" alone misses typing
+    // in the body — lexxy:change is the editor's own any-edit signal.
+    this.editorListener = () => this.contentChanged()
+    this.editorTarget.addEventListener("lexxy:change", this.editorListener)
+    this.editorTarget.addEventListener("input", this.editorListener)
+
+    this.keyListener = (event) => {
+      if ((event.metaKey || event.ctrlKey) && event.key === "s") {
+        event.preventDefault()
+        this.save()
+      }
+    }
+    document.addEventListener("keydown", this.keyListener)
+
+    // Flush pending edits when leaving instead of nagging with a dialog;
+    // keepalive lets the request outlive the page. Only block navigation
+    // when a save actually failed and edits would truly be lost.
+    this.unloadListener = (event) => {
+      if (!this.dirty) return
+      this.flushSave()
+      if (this.saveFailed) {
+        event.preventDefault()
+        event.returnValue = ""
+      }
+    }
+    window.addEventListener("beforeunload", this.unloadListener)
+  }
+
+  disconnect() {
+    this.editorTarget.removeEventListener("lexxy:change", this.editorListener)
+    this.editorTarget.removeEventListener("input", this.editorListener)
+    document.removeEventListener("keydown", this.keyListener)
+    window.removeEventListener("beforeunload", this.unloadListener)
+    clearTimeout(this.saveTimer)
+  }
+
+  titleChanged() {
+    this.resizeTitle()
+    this.contentChanged()
+  }
+
+  contentChanged() {
+    this.dirty = true
+    this.setStatus("dirty", "Unsaved changes")
+    this.refreshWordCount()
+    clearTimeout(this.saveTimer)
+    this.saveTimer = setTimeout(() => this.save(), 2000)
+  }
+
+  // The top bar normally fades away; save activity has to be able to pull
+  // it back so the state change is actually seen.
+  setStatus(state, text) {
+    this.statusTarget.dataset.state = state
+    this.statusTextTarget.textContent = text
+
+    clearTimeout(this.attentionTimer)
+    if (state === "saving" || state === "error") {
+      this.barTarget.classList.add("plum-write-bar--active")
+    } else if (state === "saved") {
+      this.barTarget.classList.add("plum-write-bar--active")
+      this.attentionTimer = setTimeout(() => this.barTarget.classList.remove("plum-write-bar--active"), 1800)
+    } else {
+      this.barTarget.classList.remove("plum-write-bar--active")
+    }
+  }
+
+  save() {
+    if (this.saving) return this.savePromise
+    this.savePromise = this.performSave()
+    return this.savePromise
+  }
+
+  async performSave() {
+    clearTimeout(this.saveTimer)
+    this.saving = true
+    this.dirty = false
+    this.setStatus("saving", "Saving…")
+
+    const hidden = document.getElementById(this.editorTarget.dataset.hiddenField)
+    if (hidden) hidden.value = this.editorTarget.value
+
+    try {
+      const response = await fetch(this.formTarget.action, {
+        method: "POST",
+        body: new FormData(this.formTarget),
+        headers: { Accept: "application/json" }
+      })
+      const result = await response.json().catch(() => ({}))
+
+      if (response.ok && result.saved) {
+        const label = result.draft ? "Draft saved" : "Saved"
+        this.setStatus("saved", `${label} at ${this.timeNow()}`)
+        this.saveFailed = false
+      } else {
+        this.dirty = true
+        this.saveFailed = true
+        this.setStatus("error", (result.errors || ["Couldn't save"]).join(", "))
+      }
+    } catch {
+      this.dirty = true
+      this.saveFailed = true
+      this.setStatus("error", "Offline — changes not saved yet")
+    } finally {
+      this.saving = false
+    }
+  }
+
+  flushSave() {
+    const hidden = document.getElementById(this.editorTarget.dataset.hiddenField)
+    if (hidden) hidden.value = this.editorTarget.value
+    this.dirty = false
+    fetch(this.formTarget.action, {
+      method: "POST",
+      body: new FormData(this.formTarget),
+      headers: { Accept: "application/json" },
+      keepalive: true
+    }).catch(() => {})
+  }
+
+  async publishDraft() {
+    await this.save()
+    if (this.dirty) return // the save failed; don't publish a stale draft
+
+    this.setStatus("saving", "Publishing…")
+    try {
+      const response = await fetch(this.publishUrlValue, {
+        method: "POST",
+        headers: {
+          Accept: "application/json",
+          "X-CSRF-Token": document.querySelector('meta[name="csrf-token"]')?.content || ""
+        }
+      })
+      if (response.ok) {
+        this.setStatus("saved", `Published at ${this.timeNow()}`)
+      } else {
+        this.setStatus("error", "Couldn't publish")
+      }
+    } catch {
+      this.setStatus("error", "Offline — couldn't publish")
+    }
+  }
+
+  timeNow() {
+    return new Date().toLocaleTimeString([], { hour: "numeric", minute: "2-digit" })
+  }
+
+  resizeTitle() {
+    const title = this.titleTarget
+    title.style.height = "auto"
+    title.style.height = `${title.scrollHeight}px`
+  }
+
+  refreshWordCount() {
+    const scratch = document.createElement("div")
+    scratch.innerHTML = this.editorTarget.value || ""
+    const text = scratch.textContent || ""
+    const words = (text.trim().match(/\S+/g) || []).length
+    this.wordsTarget.textContent = `${words} ${words === 1 ? "word" : "words"}`
+  }
+}

data/app/models/plum/asset.rb

@@ -1,6 +1,7 @@
 module Plum
   class Asset < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     has_one_attached :file
 

data/app/models/plum/content_type.rb

@@ -1,6 +1,7 @@
 module Plum
   class ContentType < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     FIELD_TYPES = FieldTypeRegistry.handles.freeze
 

data/app/models/plum/entry.rb

@@ -1,6 +1,7 @@
 module Plum
   class Entry < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     belongs_to :content_type
     belongs_to :author, class_name: "Plum::User", optional: true
@@ -10,6 +11,9 @@ module Plum
     has_many :terms, through: :entry_terms
     has_many :revisions, class_name: "Plum::EntryRevision", dependent: :destroy
     has_many :translations, class_name: "Plum::Entry", foreign_key: :origin_id, dependent: :destroy
+    # A deleted entry takes its nav links with it — nav items have a FK on
+    # entry_id, so without this both entry and site destroys crash.
+    has_many :nav_items, dependent: :destroy
 
     # The page served at "/" — Plum resolves the homepage by this slug
     # (convention over configuration). Its slug is locked and it can't be
@@ -45,6 +49,49 @@ module Plum
       data&.dig(handle)
     end
 
+    # Working copy ("draft of a published entry"): pending edits stored in
+    # draft_data as { "title" => ..., "data" => {...} }. The live `title` and
+    # `data` stay untouched until publish_draft!, so the public site never
+    # sees half-written content.
+    def has_draft?
+      draft_data.present?
+    end
+
+    def draft_title
+      draft_data.to_h["title"].presence || title
+    end
+
+    def draft_field_value(handle)
+      draft_data.to_h.dig("data", handle) || field_value(handle)
+    end
+
+    def save_draft!(title: nil, data: {})
+      base = draft_data.to_h
+      merged = (base["data"] || self.data.to_h).merge(data.to_h)
+      update!(draft_data: {
+        "title" => title.presence || base["title"].presence || self.title,
+        "data" => merged
+      })
+    end
+
+    def publish_draft!(editor: nil)
+      return false unless has_draft?
+
+      transaction do
+        update!(
+          title: draft_data["title"].presence || title,
+          data: draft_data["data"] || data,
+          draft_data: nil
+        )
+        record_revision!(editor: editor)
+      end
+      true
+    end
+
+    def discard_draft!
+      update!(draft_data: nil)
+    end
+
     def homepage?
       slug == HOMEPAGE_SLUG
     end
@@ -66,6 +113,12 @@ module Plum
         }
       }
       attributes[:editor] = editor if editor.is_a?(Plum::User)
+
+      # Autosave calls this on every save; identical content shouldn't pile
+      # up as duplicate history entries.
+      last = revisions.order(id: :desc).first
+      return last if last && last.snapshot == attributes[:snapshot]
+
       revisions.create!(attributes)
     end
 
@@ -278,6 +331,10 @@ module Plum
     end
 
     def prevent_homepage_destroy
+      # Only protect the homepage while its site survives — when the whole
+      # site is going away (site destroy, plum:site:replace), the cascade
+      # must be allowed through.
+      return if destroyed_by_association
       return unless homepage?
 
       errors.add(:base, "The homepage can't be deleted")

data/app/models/plum/entry_term.rb

@@ -1,5 +1,6 @@
 module Plum
   class EntryTerm < ApplicationRecord
+    include StaticCacheInvalidation
     belongs_to :entry
     belongs_to :term
 

data/app/models/plum/form_definition.rb

@@ -1,6 +1,7 @@
 module Plum
   class FormDefinition < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     FIELD_TYPES = %w[text email textarea select checkbox].freeze
     HANDLE_PATTERN = /\A[a-z][a-z0-9_]*\z/

data/app/models/plum/global.rb

@@ -1,6 +1,7 @@
 module Plum
   class Global < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     validates :name, presence: true
     validates :handle, presence: true, uniqueness: { scope: :site_id }, format: { with: /\A[a-z][a-z0-9_]*\z/ }

data/app/models/plum/nav_item.rb

@@ -1,6 +1,7 @@
 module Plum
   class NavItem < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     belongs_to :nav_menu
     belongs_to :parent, class_name: "Plum::NavItem", optional: true

data/app/models/plum/nav_menu.rb

@@ -1,6 +1,7 @@
 module Plum
   class NavMenu < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     has_many :nav_items, dependent: :destroy
 

data/app/models/plum/site.rb

@@ -1,5 +1,7 @@
 module Plum
   class Site < ApplicationRecord
+    include StaticCacheInvalidation
+
     belongs_to :owner, polymorphic: true, optional: true
 
     has_one :site_setting, dependent: :destroy

data/app/models/plum/site_setting.rb

@@ -1,6 +1,7 @@
 module Plum
   class SiteSetting < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     before_validation :set_defaults
     after_save :sync_site_summary

data/app/models/plum/static_cache_invalidation.rb

@@ -0,0 +1,30 @@
+module Plum
+  # Flushes the static page cache whenever content that appears in rendered
+  # pages changes. Flushing is deletion-only and per-site, so being liberal
+  # here costs one lazy re-render per page, never a wrong page.
+  module StaticCacheInvalidation
+    extend ActiveSupport::Concern
+
+    included do
+      after_commit :flush_plum_static_cache
+    end
+
+    # Columns that never appear in rendered pages — saves touching only these
+    # (draft autosaves) keep the cache warm.
+    CACHE_IRRELEVANT_COLUMNS = %w[draft_data updated_at].freeze
+
+    private
+
+    def flush_plum_static_cache
+      return unless Plum::StaticCache.enabled?
+
+      changed = respond_to?(:saved_changes) ? saved_changes.keys : []
+      return if changed.present? && (changed - CACHE_IRRELEVANT_COLUMNS).empty?
+
+      owner = is_a?(Plum::Site) ? self : (respond_to?(:site) ? site : nil)
+      Plum::StaticCache.flush_site!(owner)
+    rescue StandardError => e
+      Rails.logger.error("[Plum] static cache flush failed: #{e.message}")
+    end
+  end
+end

data/app/models/plum/taxonomy.rb

@@ -1,6 +1,7 @@
 module Plum
   class Taxonomy < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     has_many :terms, dependent: :destroy
 

data/app/models/plum/term.rb

@@ -1,6 +1,7 @@
 module Plum
   class Term < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     belongs_to :taxonomy
 

data/app/services/plum/config_sync.rb

@@ -0,0 +1,252 @@
+require "yaml"
+
+module Plum
+  # Config-as-code (phase 1): the content model lives as YAML files in the
+  # host repo and syncs into the database, like db:migrate for content types.
+  #
+  #   plum/content_types/posts.yml  ->  Plum::ContentType (blueprint)
+  #   plum/fieldsets/seo.yml        ->  Plum::Fieldset
+  #
+  # Files are the source of truth; `apply` upserts the DB from them, `export`
+  # writes the DB back out (bootstrap + CP write-back later), and `check`
+  # reports drift for CI. Content (entries, terms, assets) is never touched.
+  class ConfigSync
+    Result = Struct.new(:created, :updated, :unchanged, :deleted, keyword_init: true) do
+      def summary
+        "#{created.length} created, #{updated.length} updated, #{unchanged.length} unchanged, #{deleted.length} deleted"
+      end
+    end
+
+    class DriftError < StandardError; end
+    class UnsafePruneError < StandardError; end
+
+    CONTENT_TYPE_DIR = "content_types".freeze
+    FIELDSET_DIR = "fieldsets".freeze
+
+    def self.export(site:, dir:)
+      new(site: site, dir: dir).export
+    end
+
+    def self.apply(site:, dir:, prune: false, force: false)
+      new(site: site, dir: dir).apply(prune: prune, force: force)
+    end
+
+    def self.check(site:, dir:)
+      new(site: site, dir: dir).check
+    end
+
+    def initialize(site:, dir:)
+      @site = site
+      @dir = Pathname(dir)
+    end
+
+    # DB -> files. Mirrors the database exactly: stale files for handles that
+    # no longer exist are removed.
+    def export
+      written = []
+      written += export_kind(CONTENT_TYPE_DIR, content_types.order(:handle)) { |record| content_type_config(record) }
+      written += export_kind(FIELDSET_DIR, fieldsets.order(:handle)) { |record| fieldset_config(record) }
+      written
+    end
+
+    # Files -> DB. Upserts by handle inside a transaction. Deleting requires
+    # prune: true, and deleting a content type that still has entries
+    # additionally requires force: true.
+    def apply(prune: false, force: false)
+      result = Result.new(created: [], updated: [], unchanged: [], deleted: [])
+
+      site.transaction do
+        apply_content_types(result)
+        apply_fieldsets(result)
+        prune_missing(result, force: force) if prune
+      end
+
+      result
+    end
+
+    # Returns human-readable drift lines; empty means files and DB agree.
+    def check
+      drift = []
+      drift += check_kind(CONTENT_TYPE_DIR, content_types)
+      drift += check_kind(FIELDSET_DIR, fieldsets)
+      drift
+    end
+
+    private
+
+    attr_reader :site, :dir
+
+    # Fresh relations every time — going through site.content_types would
+    # cache the association on the site instance and hide later DB changes
+    # from repeated check/apply calls.
+    def content_types
+      ContentType.for_site(site)
+    end
+
+    def fieldsets
+      Fieldset.for_site(site)
+    end
+
+    def export_kind(subdir, records)
+      path = dir.join(subdir)
+      path.mkpath
+      keep = []
+
+      records.each do |record|
+        file = path.join("#{record.handle}.yml")
+        file.write(yaml_for(yield(record)))
+        keep << file
+      end
+
+      path.glob("*.yml").each { |file| file.delete unless keep.include?(file) }
+      keep
+    end
+
+    def apply_content_types(result)
+      each_config(CONTENT_TYPE_DIR) do |config, file|
+        record = content_types.find_or_initialize_by(handle: config.fetch("handle"))
+        record.site = site if record.new_record?
+        record.name = config["name"]
+        record.icon = config["icon"]
+        record.singleton = config["singleton"] unless config["singleton"].nil?
+        record.blueprint = merged_blueprint(record, config)
+        track(result, record, file)
+      end
+    end
+
+    def apply_fieldsets(result)
+      each_config(FIELDSET_DIR) do |config, file|
+        record = fieldsets.find_or_initialize_by(handle: config.fetch("handle"))
+        record.site = site if record.new_record?
+        record.name = config["name"]
+        record.fields = config["fields"] || []
+        track(result, record, file)
+      end
+    end
+
+    # Blueprint keys the files don't know about are preserved so config
+    # written by newer Plum versions survives a sync from older files.
+    def merged_blueprint(record, config)
+      blueprint = (record.blueprint || {}).deep_dup
+      blueprint["fields"] = config["fields"] || []
+      if config["route_prefix"].present?
+        blueprint["route_prefix"] = config["route_prefix"]
+      else
+        blueprint.delete("route_prefix")
+      end
+      blueprint
+    end
+
+    def track(result, record, file)
+      if record.new_record?
+        record.save!
+        result.created << record.handle
+      elsif record.changed?
+        record.save!
+        result.updated << record.handle
+      else
+        result.unchanged << record.handle
+      end
+    rescue ActiveRecord::RecordInvalid => e
+      raise ActiveRecord::RecordInvalid.new(e.record), "#{file.basename}: #{e.message}"
+    end
+
+    def prune_missing(result, force:)
+      file_handles = handles_in(CONTENT_TYPE_DIR)
+      content_types.where.not(handle: file_handles).find_each do |record|
+        if record.entries.exists? && !force
+          raise UnsafePruneError,
+                "Content type '#{record.handle}' has #{record.entries.count} entries; " \
+                "re-run with FORCE=1 to delete them"
+        end
+        record.destroy!
+        result.deleted << record.handle
+      end
+
+      fieldsets.where.not(handle: handles_in(FIELDSET_DIR)).find_each do |record|
+        record.destroy!
+        result.deleted << record.handle
+      end
+    end
+
+    def handles_in(subdir)
+      handles = []
+      each_config(subdir) { |config, _file| handles << config.fetch("handle") }
+      handles
+    end
+
+    def check_kind(subdir, records)
+      drift = []
+      configs = {}
+      each_config(subdir) { |config, _file| configs[config.fetch("handle")] = config }
+
+      db = records.index_by(&:handle)
+      configs.each do |handle, config|
+        record = db[handle]
+        if record.nil?
+          drift << "#{subdir}/#{handle}: in files but not in the database"
+        elsif normalize(subdir, config_for(subdir, record)) != normalize(subdir, config)
+          drift << "#{subdir}/#{handle}: files and database differ"
+        end
+      end
+      (db.keys - configs.keys).each do |handle|
+        drift << "#{subdir}/#{handle}: in the database but not in files"
+      end
+      drift
+    end
+
+    def config_for(subdir, record)
+      subdir == CONTENT_TYPE_DIR ? content_type_config(record) : fieldset_config(record)
+    end
+
+    # Key order and empty-vs-absent values must not register as drift.
+    def normalize(subdir, config)
+      if subdir == CONTENT_TYPE_DIR
+        {
+          "name" => config["name"].to_s,
+          "handle" => config["handle"].to_s,
+          "icon" => config["icon"].presence,
+          "singleton" => !!config["singleton"],
+          "route_prefix" => config["route_prefix"].presence,
+          "fields" => config["fields"] || []
+        }
+      else
+        {
+          "name" => config["name"].to_s,
+          "handle" => config["handle"].to_s,
+          "fields" => config["fields"] || []
+        }
+      end
+    end
+
+    def content_type_config(record)
+      config = {
+        "name" => record.name,
+        "handle" => record.handle,
+        "icon" => record.icon,
+        "singleton" => record.singleton,
+        "route_prefix" => record.route_prefix,
+        "fields" => record.fields
+      }
+      config.reject { |_key, value| value.nil? }
+    end
+
+    def fieldset_config(record)
+      { "name" => record.name, "handle" => record.handle, "fields" => record.fields || [] }
+    end
+
+    def each_config(subdir)
+      dir.join(subdir).glob("*.yml").sort.each do |file|
+        config = YAML.safe_load(file.read, aliases: true)
+        raise DriftError, "#{file} is not a YAML mapping" unless config.is_a?(Hash)
+
+        config["handle"] ||= file.basename(".yml").to_s
+        yield config, file
+      end
+    end
+
+    def yaml_for(config)
+      config.to_yaml
+    end
+  end
+end