iron-cms 0.17.2 → 0.18.0

data/app/helpers/iron/avatar_helper.rb

@@ -1,5 +1,7 @@
 module Iron
   module AvatarHelper
+    SYSTEM_AVATAR_CLASSES = "bg-sky-100 text-sky-600 dark:bg-sky-500/20 dark:text-sky-400"
+
     def avatar(user, options = {})
       variant = options.delete(:variant) || "circle"
       alt = options.delete(:alt) || ""
@@ -9,10 +11,31 @@ module Iron
         "inline-grid shrink-0 align-middle [--avatar-radius:20%] [--ring-opacity:20%] *:col-start-1 *:row-start-1",
         "outline outline-1 -outline-offset-1 outline-black/(--ring-opacity) dark:outline-white/(--ring-opacity)",
         # Add the correct border radius
-        variant == "square" ? "rounded-(--avatar-radius) *:rounded-(--avatar-radius)" : "rounded-full *:rounded-full"
+        variant == "square" ? "rounded-(--avatar-radius) *:rounded-(--avatar-radius)" : "rounded-full *:rounded-full",
+        # The system user wears the accent treatment instead of the caller's palette
+        user.iron_system? ? SYSTEM_AVATAR_CLASSES : nil
       )
 
       tag.span class: css_class, data: { slot: "avatar" } do
+        user.iron_system? ? system_glyph : initials_glyph(user, alt)
+      end
+    end
+
+    def user_icon(user, **options)
+      user.iron_system? ? system_icon(**options) : icon("circle-user", **options)
+    end
+
+    def system_icon(**options)
+      icon "bot", **options
+    end
+
+    private
+
+      def system_glyph
+        system_icon class: "size-full p-[22%]"
+      end
+
+      def initials_glyph(user, alt)
         tag.svg class: "size-full select-none fill-current p-[5%] text-[48px] font-medium uppercase",
           viewbox: "0 0 100 100",
           "aria-hidden": alt.present? ? nil : true do
@@ -30,6 +53,5 @@ module Iron
           ])
         end
       end
-    end
   end
 end

data/app/javascript/iron/controllers/file_upload_controller.js

@@ -1,7 +1,7 @@
 import { Controller } from "@hotwired/stimulus";
 
 export default class FileUploadController extends Controller {
-  static targets = ["preview", "placeholder", "previewWrapper"];
+  static targets = ["preview", "placeholder", "previewWrapper", "filename"];
 
   connect() {
     if (this.hasPreviewTarget) {
@@ -16,19 +16,27 @@ export default class FileUploadController extends Controller {
     const file = event.target.files[0];
     if (!file) return;
 
-    if (this.hasPreviewTarget) {
-      this.previewTarget.src = URL.createObjectURL(file);
-    }
-    if (this.hasPlaceholderTarget) {
-      this.placeholderTarget.classList.add("hidden");
+    const kind = this.#kindOf(file.type);
+
+    if (kind === "image") {
+      if (this.hasPreviewTarget) {
+        this.previewTarget.src = URL.createObjectURL(file);
+      }
+    } else if (this.hasFilenameTarget) {
+      this.filenameTarget.textContent = file.name;
     }
-    this.previewElement?.classList.remove("hidden");
+
+    this.#markFileKind(kind);
+    this.#revealPreview();
   }
 
   reset() {
     if (this.hasPreviewTarget) {
       this.previewTarget.src = this.originalSrc;
     }
+    if (this.hasPreviewWrapperTarget) {
+      delete this.previewWrapperTarget.dataset.fileKind;
+    }
     if (this.originalHidden) {
       this.previewElement?.classList.add("hidden");
       if (this.hasPlaceholderTarget) {
@@ -42,4 +50,27 @@ export default class FileUploadController extends Controller {
     if (this.hasPreviewTarget) return this.previewTarget;
     return null;
   }
+
+  // Private
+
+  #markFileKind(kind) {
+    if (this.hasPreviewWrapperTarget) {
+      this.previewWrapperTarget.dataset.fileKind = kind;
+    }
+  }
+
+  #revealPreview() {
+    if (this.hasPlaceholderTarget) {
+      this.placeholderTarget.classList.add("hidden");
+    }
+    this.previewElement?.classList.remove("hidden");
+  }
+
+  #kindOf(contentType) {
+    if (contentType.startsWith("image/")) return "image";
+    if (contentType === "application/pdf") return "pdf";
+    if (contentType.startsWith("audio/")) return "audio";
+    if (contentType.startsWith("video/")) return "video";
+    return "file";
+  }
 }

data/app/models/iron/account.rb

@@ -1,6 +1,6 @@
 module Iron
   class Account < ApplicationRecord
-    include Joinable
+    include Joinable, Schema::AutoDumpable
 
     has_secure_token :instance_token
 

data/app/models/iron/api/openapi_spec.rb

@@ -208,7 +208,7 @@ module Iron
             },
             ValidationErrors: {
               type: "object",
-              description: "Field handle to error messages mapping",
+              description: "Field path to error messages mapping. Paths may be nested, e.g. `sections[0].title`.",
               additionalProperties: { type: "array", items: { type: "string" } }
             },
             FileObject: {
@@ -275,7 +275,7 @@ module Iron
 
           ct.field_definitions.each do |fd|
             content_properties[fd.handle.to_sym] = field_write_schema(fd)
-            required_fields << fd.handle if fd.respond_to?(:required) && fd.required
+            required_fields << fd.handle if fd.required?
           end
 
           content_schema = { type: "object", properties: content_properties }
@@ -307,7 +307,7 @@ module Iron
             properties[fd.handle.to_sym] = field_write_schema(fd)
           end
 
-          { type: "object", properties: properties, required: [ "_type" ] }
+          { type: "object", properties: properties, required: [ "_type" ] + bd.field_definitions.select(&:required?).map(&:handle) }
         end
 
         # --- Field type mapping ---
@@ -315,12 +315,12 @@ module Iron
         def field_read_schema(fd)
           case fd
           when FieldDefinitions::TextField
-            schema = { type: [ "string", "null" ] }
-            schema[:enum] = fd.allowed_values + [ nil ] if fd.respond_to?(:allowed_values) && fd.allowed_values.present?
+            schema = { type: [ "string", "null" ] }.merge(length_bounds(fd))
+            schema[:enum] = fd.allowed_values + [ nil ] if fd.allowed_values.present?
             schema
-          when FieldDefinitions::TextArea     then { type: [ "string", "null" ] }
+          when FieldDefinitions::TextArea     then { type: [ "string", "null" ] }.merge(length_bounds(fd))
           when FieldDefinitions::RichTextArea then { oneOf: [ { "$ref": "#/components/schemas/RichText" }, { type: "null" } ] }
-          when FieldDefinitions::Number       then { type: [ "number", "null" ] }
+          when FieldDefinitions::Number       then { type: [ "number", "null" ] }.merge(number_bounds(fd))
           when FieldDefinitions::Boolean      then { type: [ "boolean", "null" ] }
           when FieldDefinitions::Date         then { type: [ "string", "null" ], format: "date-time" }
           when FieldDefinitions::File         then { oneOf: [ { "$ref": "#/components/schemas/FileObject" }, { type: "null" } ] }
@@ -338,16 +338,16 @@ module Iron
         def field_write_schema(fd)
           case fd
           when FieldDefinitions::TextField
-            schema = { type: [ "string", "null" ] }
-            schema[:enum] = fd.allowed_values + [ nil ] if fd.respond_to?(:allowed_values) && fd.allowed_values.present?
+            schema = { type: write_type(fd, "string") }.merge(length_bounds(fd))
+            schema[:enum] = fd.required? ? fd.allowed_values : fd.allowed_values + [ nil ] if fd.allowed_values.present?
             schema
-          when FieldDefinitions::TextArea     then { type: [ "string", "null" ] }
-          when FieldDefinitions::RichTextArea then { type: [ "string", "null" ], description: "HTML content" }
-          when FieldDefinitions::Number       then { type: [ "number", "null" ] }
+          when FieldDefinitions::TextArea     then { type: write_type(fd, "string") }.merge(length_bounds(fd))
+          when FieldDefinitions::RichTextArea then { type: write_type(fd, "string"), description: "HTML content" }
+          when FieldDefinitions::Number       then { type: write_type(fd, "number") }.merge(number_bounds(fd))
           when FieldDefinitions::Boolean      then { type: [ "boolean", "null" ] }
-          when FieldDefinitions::Date         then { type: [ "string", "null" ], format: "date-time" }
-          when FieldDefinitions::File         then { oneOf: [ { type: "string", description: "Upload token (signed_id)" }, { type: "null" } ] }
-          when FieldDefinitions::Reference    then { oneOf: [ { type: "integer", description: "Entry ID" }, { type: "null" } ] }
+          when FieldDefinitions::Date         then { type: write_type(fd, "string"), format: "date-time" }
+          when FieldDefinitions::File         then nullable_unless_required(fd, type: "string", description: upload_token_description(fd))
+          when FieldDefinitions::Reference    then nullable_unless_required(fd, type: "integer", description: "Entry ID")
           when FieldDefinitions::ReferenceList then { type: "array", items: { type: "integer", description: "Entry ID" } }
           when FieldDefinitions::Block
             bd = fd.supported_block_definition
@@ -358,6 +358,28 @@ module Iron
           end
         end
 
+        def write_type(fd, type)
+          fd.required? ? type : [ type, "null" ]
+        end
+
+        def nullable_unless_required(fd, schema)
+          fd.required? ? schema : { oneOf: [ schema, { type: "null" } ] }
+        end
+
+        def length_bounds(fd)
+          { minLength: fd.min_length, maxLength: fd.max_length }.compact
+        end
+
+        def number_bounds(fd)
+          { minimum: fd.min, maximum: fd.max }.compact
+        end
+
+        def upload_token_description(fd)
+          return "Upload token (signed_id)" if fd.accepted_extensions.blank?
+
+          "Upload token (signed_id). Accepted file types: #{fd.accepted_extensions.join(', ')}"
+        end
+
         # --- Helpers ---
 
         def content_types

data/app/models/iron/block_definition/exportable.rb

@@ -8,7 +8,7 @@ module Iron
         name:,
         description:,
         field_definitions: field_definitions.ranked.map(&:export_attributes)
-      }
+      }.compact_blank
     end
   end
 end

data/app/models/iron/block_definition.rb

@@ -1,6 +1,6 @@
 module Iron
   class BlockDefinition < ApplicationRecord
-    include Exportable, Importable
+    include Exportable, Importable, Schema::AutoDumpable
 
     has_many :field_definitions, -> { ranked }, as: :schemable, dependent: :destroy
 
@@ -14,5 +14,7 @@ module Iron
 
     validates :name, presence: true
     validates :handle, presence: true
+
+    def required? = false
   end
 end

data/app/models/iron/content.rb

@@ -0,0 +1,176 @@
+require "open-uri"
+
+module Iron
+  class Content
+    class Error < StandardError; end
+
+    class InvalidContent < Error
+      attr_reader :errors
+
+      def initialize(errors)
+        @errors = errors
+        super(errors.map { |path, messages| "#{path} #{Array(messages).join(", ")}" }.join("; "))
+      end
+    end
+
+    class << self
+      def list(handle, locale: nil)
+        as_system(locale) do
+          content_type(handle).entries.order(:id).map { |entry| render_entry(entry) }
+        end
+      end
+
+      def get(handle, id: nil, route: nil, locale: nil)
+        as_system(locale) do
+          render_entry(locate_entry(content_type(handle), id:, route:))
+        end
+      end
+
+      def create(handle, content, route: nil, locale: nil)
+        type = content_type(handle)
+        raise Error, "#{handle} is a single — use update" if type.single?
+
+        as_system(locale) do
+          entry = type.entries.build
+          entry.route = route if route
+          write_entry(entry, content)
+        end
+      end
+
+      def update(handle, content, id: nil, route: nil, locale: nil)
+        type = content_type(handle)
+
+        as_system(locale) do
+          write_entry(entry_for_update(type, id:, route:), content)
+        end
+      end
+
+      def delete(handle, id: nil, route: nil)
+        as_system(nil) do
+          entry = locate_entry(content_type(handle), id:, route:)
+          purge_file_attachments(entry)
+          entry.destroy!
+          { "deleted" => true, "id" => entry.id }
+        end
+      end
+
+      private
+
+        def as_system(locale_code, &block)
+          Current.set(user: User.system, locale: resolve_locale(locale_code)) do
+            ActiveStorage::Current.set(url_options: storage_url_options, &block)
+          end
+        end
+
+        def resolve_locale(code)
+          code.present? ? Locale.find_by!(code:) : Locale.default
+        end
+
+        def storage_url_options
+          Rails.application.routes.default_url_options.presence || { host: "localhost", port: 3000 }
+        end
+
+        def content_type(handle)
+          ContentType.find_by!(handle:)
+        end
+
+        def locate_entry(content_type, id:, route:)
+          if id
+            content_type.entries.find(id)
+          elsif route
+            content_type.entries.find_by!(route:)
+          else
+            singleton_entry(content_type)
+          end
+        end
+
+        def singleton_entry(content_type)
+          raise Error, "#{content_type.handle} is a collection — pass an id or route" unless content_type.single?
+
+          content_type.entry.tap do |entry|
+            raise ActiveRecord::RecordNotFound, "#{content_type.handle} has no entry yet" unless entry.persisted?
+          end
+        end
+
+        def entry_for_update(content_type, id:, route:)
+          if id.nil? && route.nil? && content_type.single?
+            content_type.entry
+          else
+            locate_entry(content_type, id:, route:)
+          end
+        end
+
+        def write_entry(entry, content)
+          content ||= {}
+          raise Error, "payload must be a JSON object of field handles" unless content.is_a?(Hash)
+
+          entry.assign_content(ingest_files(content))
+          raise InvalidContent, entry.content_errors unless entry.save
+
+          render_entry(entry)
+        end
+
+        def purge_file_attachments(entry)
+          entry.fields.each do |field|
+            field.file.purge if field.is_a?(Fields::File) && field.file.attached?
+          end
+        end
+
+        def render_entry(entry)
+          JSON.parse(Api::BaseController.render(partial: "iron/api/entry", formats: [ :json ], locals: { entry: }))
+        end
+
+        def ingest_files(content)
+          case content
+          when Hash
+            if file_directive?(content)
+              uploaded_blob(file_source(content)).signed_id
+            else
+              content.transform_values { |value| ingest_files(value) }
+            end
+          when Array
+            content.map { |value| ingest_files(value) }
+          else
+            content
+          end
+        end
+
+        def file_directive?(hash)
+          hash.key?("_file") || hash.key?(:_file)
+        end
+
+        def file_source(hash)
+          hash["_file"] || hash[:_file]
+        end
+
+        def uploaded_blob(source)
+          unless source.is_a?(String) && source.present?
+            raise Error, '"_file" must be a file path or URL string'
+          end
+
+          source.match?(%r{\Ahttps?://}i) ? downloaded_blob(source) : local_blob(source)
+        end
+
+        def downloaded_blob(url)
+          URI.open(url) do |io|
+            ActiveStorage::Blob.create_and_upload!(io:, filename: File.basename(URI.parse(url).path))
+          end
+        rescue OpenURI::HTTPError, SocketError, URI::InvalidURIError, Timeout::Error, Errno::ECONNREFUSED => error
+          raise Error, "could not download #{url}: #{error.message}"
+        end
+
+        def local_blob(path)
+          file = Pathname.new(path)
+          file = Rails.root.join(file) if file.relative?
+
+          file.open do |io|
+            ActiveStorage::Blob.create_and_upload!(io:, filename: file.basename.to_s)
+          end
+        rescue Errno::ENOENT
+          raise Error, "file not found: #{path} (paths are relative to the app root)"
+        rescue Errno::EACCES, Errno::EISDIR => error
+          raise Error, "could not read file #{path}: #{error.message}"
+        end
+    end
+  end
+end

data/app/models/iron/content_type/exportable.rb

@@ -2,6 +2,8 @@ module Iron
   module ContentType::Exportable
     extend ActiveSupport::Concern
 
+    # Blank attributes and false flags are omitted: schema files stay canonical
+    # and hand-written files don't churn under the development auto-dump.
     def export_attributes
       {
         handle:,
@@ -14,7 +16,7 @@ module Iron
         title_field_handle: title_field_definition&.handle,
         web_page_title_field_handle: web_page_title_field_definition&.handle,
         field_definitions: field_definitions.ranked.map(&:export_attributes)
-      }
+      }.compact_blank
     end
   end
 end

data/app/models/iron/content_type/importable.rb

@@ -11,7 +11,7 @@ module Iron
           name: attrs[:name],
           description: attrs[:description],
           icon: attrs[:icon],
-          web_publishing_enabled: attrs[:web_publishing_enabled],
+          web_publishing_enabled: !!attrs[:web_publishing_enabled],
           base_path: attrs[:base_path]
         )
 

data/app/models/iron/content_type.rb

@@ -1,8 +1,9 @@
 module Iron
   class ContentType < ApplicationRecord
-    include Titlable, WebPublishable, Exportable, Importable
+    include Titlable, WebPublishable, Exportable, Importable, Schema::AutoDumpable
 
     TYPES = %w[Single Collection].freeze
+    DEFAULT_ICON = "file-text"
 
     validates :name, presence: true
     validates :handle, presence: true
@@ -36,6 +37,10 @@ module Iron
       type.demodulize
     end
 
+    def display_icon
+      icon.presence.then { |name| IconCatalog.include?(name) ? name : nil } || DEFAULT_ICON
+    end
+
     def single?
       is_a?(ContentTypes::Single)
     end

data/app/models/iron/entry/content_assignable.rb

@@ -5,7 +5,11 @@ module Iron
     def assign_content(content)
       content_type.field_definitions.each do |definition|
         raw_value = Field.content_fetch(content, definition.handle)
-        next if raw_value == Field::CONTENT_MISSING
+
+        if raw_value == Field::CONTENT_MISSING
+          find_or_build_field(definition, Current.locale) if definition.required?
+          next
+        end
 
         field = find_or_build_field(definition, Current.locale)
         field.content_value = raw_value
@@ -17,7 +21,11 @@ module Iron
 
       errors.each do |error|
         next if error.type == :fields_invalid
-        (details[error.attribute.to_s] ||= []) << error.message
+
+        attribute = error.attribute.to_s
+        next if attribute == "fields" || attribute.start_with?("fields.")
+
+        (details[attribute] ||= []) << error.message
       end
 
       collect_field_error_details(fields.select { |f| f.parent.nil? }, nil, details)

data/app/models/iron/exporter.rb

@@ -40,32 +40,7 @@ module Iron
       end
 
       def schema_json
-        JSON.pretty_generate(
-          version: "1.0",
-          exported_at: Time.current.iso8601,
-          default_locale: Current.account&.default_locale&.code,
-          locales: export_locales,
-          block_definitions: export_block_definitions,
-          content_types: export_content_types
-        )
-      end
-
-      def export_locales
-        Locale.order(:code).map { |l| { code: l.code, name: l.name } }
-      end
-
-      def export_block_definitions
-        BlockDefinition
-          .includes(:field_definitions)
-          .order(:handle)
-          .map(&:export_attributes)
-      end
-
-      def export_content_types
-        ContentType
-          .includes(:title_field_definition, :web_page_title_field_definition, :field_definitions)
-          .order(:handle)
-          .map(&:export_attributes)
+        Schema.to_json
       end
 
       def exportable_entries

data/app/models/iron/field/length_constrained.rb

@@ -0,0 +1,17 @@
+module Iron
+  module Field::LengthConstrained
+    extend ActiveSupport::Concern
+
+    included do
+      validate :value_within_length_bounds
+    end
+
+    private
+      def value_within_length_bounds
+        return if value.blank?
+
+        errors.add(:base, :too_short, count: definition.min_length) if definition.min_length && value.length < definition.min_length
+        errors.add(:base, :too_long, count: definition.max_length) if definition.max_length && value.length > definition.max_length
+      end
+  end
+end

data/app/models/iron/field/validatable.rb

@@ -0,0 +1,16 @@
+module Iron
+  module Field::Validatable
+    extend ActiveSupport::Concern
+
+    included do
+      validate :enforce_required
+    end
+
+    def filled? = true
+
+    private
+      def enforce_required
+        errors.add(:base, :blank) if definition&.required? && !filled?
+      end
+  end
+end

data/app/models/iron/field.rb

@@ -1,6 +1,6 @@
 module Iron
   class Field < ApplicationRecord
-    include BelongsToEntry
+    include BelongsToEntry, Validatable
 
     TYPES = %w[text_field text_area rich_text_area number file boolean date block block_list reference_list reference].freeze
     CONTENT_MISSING = Object.new.freeze

data/app/models/iron/field_definition/exportable.rb

@@ -7,15 +7,14 @@ module Iron
         handle:,
         name:,
         type: type_handle,
-        rank:,
-        metadata:
+        metadata: metadata.compact_blank
       }.tap do |attrs|
         if respond_to?(:supported_block_definitions)
-          attrs[:supported_block_definitions] = supported_block_definitions.pluck(:handle)
+          attrs[:supported_block_definitions] = supported_block_definitions.pluck(:handle).sort
         end
 
         if respond_to?(:supported_content_types)
-          attrs[:supported_content_types] = supported_content_types.pluck(:handle)
+          attrs[:supported_content_types] = supported_content_types.pluck(:handle).sort
         end
       end.compact_blank
     end

data/app/models/iron/field_definition/importable.rb

@@ -7,11 +7,11 @@ module Iron
         raise ArgumentError, "Field type is required" unless attrs[:type].present?
 
         field_def = schemable.field_definitions.find_or_initialize_by(handle: attrs[:handle])
+        discard_stored_values(field_def, attrs[:type])
         field_def = field_def.becomes!(classify_type(attrs[:type]).constantize)
 
         field_def.assign_attributes(
           name: attrs[:name],
-          rank: attrs[:rank],
           metadata: attrs[:metadata] || {}
         )
 
@@ -21,19 +21,26 @@ module Iron
         field_def
       end
 
-      private
-
+      # Omitted lists clear the supported definitions: the file is authoritative.
+      # Handles declared later in the same file resolve in Schema.import's second
+      # pass, once every block definition and content type exists.
       def assign_supported_definitions(field_def, attrs)
-        if field_def.respond_to?(:supported_block_definition_ids=) && attrs[:supported_block_definitions].present?
-          block_defs = BlockDefinition.where(handle: attrs[:supported_block_definitions])
-          field_def.supported_block_definition_ids = block_defs.pluck(:id)
+        if field_def.respond_to?(:supported_block_definition_ids=)
+          field_def.supported_block_definition_ids = BlockDefinition.where(handle: attrs[:supported_block_definitions] || []).pluck(:id)
         end
 
-        if field_def.respond_to?(:supported_content_type_ids=) && attrs[:supported_content_types].present?
-          content_types = ContentType.where(handle: attrs[:supported_content_types])
-          field_def.supported_content_type_ids = content_types.pluck(:id)
+        if field_def.respond_to?(:supported_content_type_ids=)
+          field_def.supported_content_type_ids = ContentType.where(handle: attrs[:supported_content_types] || []).pluck(:id)
         end
       end
+
+      private
+
+      # Changing a field's type discards its stored values: rows written under
+      # the old field class would otherwise linger as split-brain content.
+      def discard_stored_values(field_def, type)
+        field_def.fields.destroy_all if field_def.persisted? && field_def.type != classify_type(type)
+      end
     end
   end
 end

data/app/models/iron/field_definition/ranked.rb

@@ -4,7 +4,7 @@ module Iron
 
     included do
       has_rank scoped_by: :schemable
-      before_create :move_to_bottom
+      before_create :move_to_bottom, if: :no_rank?
     end
   end
 end

data/app/models/iron/field_definition/searchable.rb

@@ -19,6 +19,8 @@ module Iron
     end
 
     def searchable=(value)
+      raise ActiveModel::UnknownAttributeError.new(self, "searchable") unless SEARCHABLE_TYPES.include?(self.class.name)
+
       self.metadata = (metadata || {}).merge("searchable" => ActiveModel::Type::Boolean.new.cast(value))
     end