rivet_cms 0.1.2.pre → 0.3.1

data/app/serializers/rivet_cms/revision_serializer.rb

@@ -0,0 +1,123 @@
+module RivetCms
+  class RevisionSerializer
+    RICH_TEXT_TAGS = %w[p br strong em b i u s del a img ul ol li h1 h2 h3 h4 h5 h6 blockquote pre code hr].freeze
+    RICH_TEXT_ATTRS = %w[href src alt title class target rel width height style].freeze
+
+    # fields: root-level key whitelist (nil = all). populate: reference Field
+    # records to expand one level deep. preview: serve draft targets and skip
+    # the published-only relation filter. preload: a shared RevisionPreloader
+    # (built automatically for single-revision use).
+    def initialize(revision, fields: nil, populate: [], preview: false, preload: nil)
+      @revision = revision
+      @field_keys = fields
+      @populate = populate
+      @populate_field_ids = populate.map(&:id).to_set
+      @preview = preview
+      @preload = preload
+    end
+
+    def as_json(*)
+      return nil if @revision.nil?
+
+      @preload ||= RevisionPreloader.new([ @revision ], populate_fields: @populate, preview: @preview)
+      document = @preload.document_for(@revision)
+      fields = @preload.fields_for_content_type(document.content_type_id)
+      fields = fields.select { |field| @field_keys.include?(field.key) } if @field_keys
+
+      {
+        id: document.prefix_id,
+        slug: document.slug,
+        content_type: document.content_type.slug,
+        state: @revision.state,
+        data: serialize_owner(@revision, fields, root: true)
+      }
+    end
+
+    private
+
+    def serialize_owner(owner, fields, root:)
+      fields.each_with_object({}) do |field, data|
+        data[field.key] = serialize_field(owner, field, root: root)
+      end
+    end
+
+    def serialize_field(owner, field, root:)
+      case field.field_type
+      when "reference"
+        serialize_reference(owner, field, root: root)
+      when "component"
+        collapse(field, @preload.component_instances(owner, field).map { |instance|
+          serialize_owner(instance, @preload.fields_for_component(instance.component_id), root: false)
+        })
+      when "image", "video", "file"
+        attachment_json(@preload.value(owner, field)&.media_asset)
+      when "rich_text"
+        sanitize(@preload.value(owner, field)&.value)
+      else
+        scalar_json(@preload.value(owner, field)&.value)
+      end
+    end
+
+    # ActiveSupport encodes BigDecimal as a JSON string; the API promises a number.
+    def scalar_json(value)
+      value.is_a?(BigDecimal) ? value.to_f : value
+    end
+
+    def serialize_reference(owner, field, root:)
+      relations = visible_relations(@preload.relations(owner, field))
+
+      if root && @populate_field_ids.include?(field.id)
+        collapse(field, relations.filter_map { |relation| populated_json(relation) })
+      else
+        collapse(field, relations.map { |relation| reference_json(relation) })
+      end
+    end
+
+    # Published scope must not reveal draft-only documents, even as {id, slug}.
+    # Targets whose content type has been removed are hidden the same way, in
+    # both scopes: their type is no longer served, so neither are they.
+    def visible_relations(relations)
+      # A target can be missing entirely (trashed entry) or belong to a removed
+      # type; either way it is no longer served, so neither is the reference.
+      visible = relations.reject { |relation| relation.target_document.nil? || relation.target_document.content_type.nil? }
+      return visible if @preview
+
+      visible.reject { |relation| relation.target_document.published_revision_id.nil? }
+    end
+
+    def reference_json(relation)
+      { id: relation.target_document.prefix_id, slug: relation.target_document.slug }
+    end
+
+    def populated_json(relation)
+      target = relation.target_document
+      revision = @preload.target_revision(target.id)
+      return nil if revision.nil?
+
+      {
+        id: target.prefix_id,
+        slug: target.slug,
+        content_type: target.content_type.slug,
+        state: revision.state,
+        data: serialize_owner(revision, @preload.fields_for_content_type(target.content_type_id), root: false)
+      }
+    end
+
+    def attachment_json(asset)
+      return nil unless asset
+
+      { id: asset.prefix_id, filename: asset.filename, content_type: asset.content_type, byte_size: asset.byte_size,
+        title: asset.title, alt: asset.alt, description: asset.description, url: asset.url }
+    end
+
+    def collapse(field, items)
+      field.max_items == 1 ? items.first : items
+    end
+
+    def sanitize(html)
+      return nil if html.blank?
+
+      ActionController::Base.helpers.sanitize(html.to_s, tags: RICH_TEXT_TAGS, attributes: RICH_TEXT_ATTRS)
+    end
+  end
+end

data/app/services/rivet_cms/content_query.rb

@@ -0,0 +1,158 @@
+module RivetCms
+  # Builds the published-document query for one content type: whitelisted sort,
+  # date-range filters, pagination clamp, and populate/fields validation.
+  # Shared by the delivery API controller and the Ruby content helpers so both
+  # access paths keep identical semantics.
+  class ContentQuery
+    class Error < StandardError; end
+
+    DEFAULT_PER_PAGE = 25
+    MAX_PER_PAGE = 100
+    DOCUMENT_SORTS = { "created_at" => :created_at, "updated_at" => :updated_at, "slug" => :slug }.freeze
+
+    def initialize(content_type, sort: nil, filters: {}, page: nil, per_page: nil, populate: nil, fields: nil)
+      @content_type = content_type
+      @sort = sort
+      @filters = normalize_filters(filters)
+      @page = page
+      @per_page = per_page
+      @populate = populate
+      @fields = fields
+    end
+
+    # Kaminari page of published documents, ordered and filtered.
+    def documents
+      base = @content_type.documents.where.not(published_revision_id: nil).includes(:published_revision)
+      ordered(filtered(base)).page(@page).per(per_page)
+    end
+
+    # Validated reference Field records to expand, already dropped when a
+    # fields selection excludes them so their targets are never preloaded.
+    def populate_fields
+      @populate_fields ||= begin
+        populate = resolve_populate
+        keys = field_keys
+        keys ? populate.select { |field| keys.include?(field.key) } : populate
+      end
+    end
+
+    def field_keys
+      return @field_keys if defined?(@field_keys)
+
+      keys = normalize_list(@fields)
+      return @field_keys = nil if keys.empty?
+
+      unknown = keys - @content_type.fields.kept.pluck(:key)
+      raise Error, "unknown field: #{unknown.first}" if unknown.any?
+
+      @field_keys = keys
+    end
+
+    private
+
+    def per_page
+      requested = @per_page.to_i
+      requested = DEFAULT_PER_PAGE if requested <= 0
+      requested.clamp(1, MAX_PER_PAGE)
+    end
+
+    def reference_fields
+      @reference_fields ||= @content_type.fields.kept.reference.ordered.to_a
+    end
+
+    def resolve_populate
+      return reference_fields if @populate == :all || @populate.to_s.strip == "*"
+
+      normalize_list(@populate).map do |key|
+        reference_fields.find { |field| field.key == key } ||
+          raise(Error, "cannot populate field: #{key}")
+      end
+    end
+
+    # Accepts the API's comma-separated string or a Ruby array of keys/symbols.
+    def normalize_list(raw)
+      list = raw.is_a?(Array) ? raw.map(&:to_s) : raw.to_s.split(",")
+      list.map(&:strip).reject(&:blank?)
+    end
+
+    # Bounds may use string or symbol gte/lte keys; values may be strings or
+    # Date/Time objects.
+    def normalize_filters(filters)
+      (filters || {}).each_with_object({}) do |(key, bounds), normalized|
+        next unless bounds.is_a?(Hash)
+
+        gte = bounds["gte"] || bounds[:gte]
+        lte = bounds["lte"] || bounds[:lte]
+        normalized[key.to_s] = { "gte" => gte, "lte" => lte } if gte.present? || lte.present?
+      end
+    end
+
+    def ordered(scope)
+      key, direction = parse_sort
+      return scope.order(DOCUMENT_SORTS.fetch(key) => direction) if DOCUMENT_SORTS.key?(key)
+
+      if key == "published_at"
+        return scope
+          .joins("INNER JOIN rivet_cms_document_revisions pub ON pub.id = rivet_cms_documents.published_revision_id")
+          .order(Arel.sql("pub.published_at #{direction}"))
+      end
+
+      field = date_field(key)
+      raise Error, "unknown sort field: #{key}" if field.nil?
+
+      scope.joins(field_join(field, "cv_sort")).order(Arel.sql("cv_sort.#{date_column(field)} #{direction}"))
+    end
+
+    def filtered(scope)
+      @filters.each_with_index do |(key, bounds), index|
+        field = date_field(key)
+        raise Error, "unknown filter field: #{key}" if field.nil?
+
+        alias_name = "cv_f#{index}"
+        scope = scope.joins(field_join(field, alias_name))
+        scope = apply_bound(scope, field, alias_name, ">=", bounds["gte"]) if bounds["gte"].present?
+        scope = apply_bound(scope, field, alias_name, "<=", bounds["lte"]) if bounds["lte"].present?
+      end
+      scope
+    end
+
+    def parse_sort
+      raw = @sort.to_s
+      return [ "published_at", :desc ] if raw.blank?
+
+      raw.start_with?("-") ? [ raw[1..], :desc ] : [ raw, :asc ]
+    end
+
+    def field_join(field, alias_name)
+      <<~SQL.squish
+        LEFT JOIN rivet_cms_content_values #{alias_name}
+          ON #{alias_name}.owner_type = 'RivetCms::DocumentRevision'
+         AND #{alias_name}.owner_id = rivet_cms_documents.published_revision_id
+         AND #{alias_name}.field_id = #{field.id.to_i}
+      SQL
+    end
+
+    def apply_bound(scope, field, alias_name, operator, value)
+      scope.where("#{alias_name}.#{date_column(field)} #{operator} ?", parse_date(field, value))
+    end
+
+    def date_field(key)
+      @content_type.fields.kept.find_by(key: key, field_type: [ :date, :datetime ])
+    end
+
+    def date_column(field)
+      field.date? ? "date_value" : "datetime_value"
+    end
+
+    def parse_date(field, value)
+      return value if value.respond_to?(:strftime)
+
+      parsed = field.date? ? Date.parse(value) : Time.zone.parse(value)
+      raise Error, "invalid date: #{value}" if parsed.nil?
+
+      parsed
+    rescue ArgumentError, TypeError, Date::Error
+      raise Error, "invalid date: #{value}"
+    end
+  end
+end

data/app/services/rivet_cms/content_validator.rb

@@ -0,0 +1,150 @@
+module RivetCms
+  class ContentValidator
+    Error = Struct.new(:field_key, :message)
+
+    attr_reader :errors
+
+    def initialize(revision)
+      @revision = revision
+      @errors = []
+    end
+
+    def valid?
+      @errors.empty?
+    end
+
+    def validate
+      raise TrashedEntryError, "entry is in the trash; restore it before validating" if @revision.document.nil?
+      raise RemovedContentTypeError, "content type was removed; restore it before validating" if content_type.nil?
+
+      validate_owner(@revision, content_type.fields.kept)
+      self
+    end
+
+    def messages
+      @errors.map { |e| "#{e.field_key} #{e.message}" }
+    end
+
+    private
+
+    def content_type
+      @revision.document.content_type
+    end
+
+    def validate_owner(owner, fields)
+      values_by_field = owner.content_values.includes(:field, :media_asset).index_by(&:field_id)
+      # Only targets that still exist: copy_owned_into drops the rest, so
+      # counting them would let a required reference publish empty.
+      relation_counts = owner.relations.where(target_document_id: Document.select(:id)).group(:field_id).count
+      instances_by_field = owner.component_instances.includes(component: :fields).group_by(&:field_id)
+
+      fields.each do |field|
+        case field.field_type
+        when "reference"
+          validate_cardinality(field, relation_counts.fetch(field.id, 0))
+        when "component"
+          validate_component_field(field, instances_by_field.fetch(field.id, []))
+        when "image", "video", "file"
+          validate_attachment_field(field, values_by_field[field.id]&.media_asset)
+        else
+          validate_scalar_field(field, values_by_field[field.id]&.value)
+        end
+      end
+    end
+
+    def validate_scalar_field(field, value)
+      return add(field, "is required") if field.required? && blank_value?(value)
+      return if blank_value?(value)
+
+      validate_config_constraints(field, value)
+    end
+
+    def validate_component_field(field, instances)
+      validate_cardinality(field, instances.size)
+      instances.each { |instance| validate_owner(instance, instance.component.fields.kept) }
+    end
+
+    def validate_attachment_field(field, asset)
+      return add(field, "is required") if field.required? && asset.nil?
+      return unless asset
+
+      validate_media(field, asset)
+    end
+
+    def validate_cardinality(field, count)
+      minimum = field.min_items || (field.required? ? 1 : 0)
+      add(field, "requires at least #{minimum}") if count < minimum
+      add(field, "allows at most #{field.max_items}") if field.max_items && count > field.max_items
+    end
+
+    def validate_config_constraints(field, value)
+      config = field.config || {}
+
+      if field.integer? || field.decimal?
+        min = numeric_bound(config["min"])
+        max = numeric_bound(config["max"])
+        add(field, "is too small") if min && value < min
+        add(field, "is too large") if max && value > max
+      elsif field.enumeration?
+        add(field, "is not a valid choice") unless Array(config["choices"]).include?(value)
+      else
+        length = value.to_s.length
+        min_length = numeric_bound(config["min_length"])&.to_i
+        max_length = numeric_bound(config["max_length"])&.to_i
+        add(field, "is too short") if min_length && length < min_length
+        add(field, "is too long") if max_length && length > max_length
+        validate_pattern(field, value, config["pattern"])
+      end
+    end
+
+    def validate_pattern(field, value, pattern)
+      return if pattern.blank?
+      return unless field.string? || field.text?
+
+      add(field, "does not match the required format") unless SafePattern.match?(pattern, value)
+    end
+
+    # Config values arrive from the admin UI as strings; comparing them
+    # against typed values directly would raise.
+    def numeric_bound(raw)
+      return nil if raw.blank?
+
+      Float(raw)
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def validate_media(field, asset)
+      config = field.config || {}
+      add(field, "has a disallowed file type") unless allowed_extension?(config["allowed_types"], asset)
+
+      max_mb = config["max_size_mb"].presence&.to_f
+      add(field, "is too large (max #{max_mb} MB)") if max_mb && asset.byte_size.to_i > max_mb * 1.megabyte
+    end
+
+    def allowed_extension?(allowed, asset)
+      list = normalize_extensions(allowed)
+      return true if list.empty?
+
+      list.include?(normalize_extension(File.extname(asset.filename.to_s)))
+    end
+
+    def normalize_extensions(allowed)
+      list = allowed.is_a?(::String) ? allowed.split(",") : Array(allowed)
+      list.map { |ext| normalize_extension(ext) }.reject(&:empty?)
+    end
+
+    def normalize_extension(ext)
+      ext = ext.to_s.strip.delete_prefix(".").downcase
+      ext == "jpeg" ? "jpg" : ext
+    end
+
+    def add(field, message)
+      @errors << Error.new(field.key, message)
+    end
+
+    def blank_value?(value)
+      value.nil? || (value.respond_to?(:empty?) && value.empty?)
+    end
+  end
+end

data/app/services/rivet_cms/draft_writer.rb

@@ -0,0 +1,74 @@
+module RivetCms
+  class DraftWriter
+    # References whose target was trashed are dropped on save; the caller
+    # reports that rather than letting the link vanish silently.
+    attr_reader :dropped_references
+
+    def initialize(revision)
+      @revision = revision
+      @dropped_references = 0
+    end
+
+    def write(values)
+      raise TrashedEntryError, "entry is in the trash; restore it before editing" if @revision.document.nil?
+
+      content_type = @revision.document.content_type
+      raise RemovedContentTypeError, "content type was removed; restore it before editing" if content_type.nil?
+
+      write_values(@revision, content_type.fields.kept, values)
+      @revision
+    end
+
+    private
+
+    def write_values(owner, fields, values)
+      fields_by_key = fields.index_by(&:key)
+
+      values.each do |key, raw|
+        field = fields_by_key[key.to_s]
+        next unless field
+
+        case field.field_type
+        when "reference"
+          write_relations(owner, field, raw)
+        when "component"
+          write_components(owner, field, raw)
+        else
+          write_scalar(owner, field, raw)
+        end
+      end
+    end
+
+    def write_scalar(owner, field, raw)
+      value = owner.content_values.find_or_initialize_by(field: field)
+      value.value = raw
+      value.save!
+    end
+
+    def write_relations(owner, field, ids)
+      owner.relations.where(field_id: field.id).destroy_all
+
+      # Silently drop targets that have been trashed since: the editor round
+      # trips their ids, and a required belongs_to would raise on save.
+      given = Array(ids).reject(&:blank?)
+      live_ids = Document.where(id: given).pluck(:id).to_set
+      live = given.select { |id| live_ids.include?(id.to_i) }
+      @dropped_references += given.size - live.size
+      live.each_with_index do |target_id, index|
+        owner.relations.create!(field: field, target_document_id: target_id, position: index)
+      end
+    end
+
+    def write_components(owner, field, entries)
+      component = Component.find_by(id: field.config&.dig("component_id"), organization_id: field.organization_id)
+      return unless component
+
+      owner.component_instances.where(field_id: field.id).destroy_all
+
+      Array(entries).each_with_index do |entry, index|
+        instance = owner.component_instances.create!(field: field, component: component, position: index)
+        write_values(instance, component.fields.kept, entry["values"] || {})
+      end
+    end
+  end
+end