iron-cms 0.1.3 → 0.2.1

data/app/controllers/iron/contents_controller.rb

@@ -0,0 +1,33 @@
+module Iron
+  class ContentsController < ApplicationController
+    before_action :ensure_can_administer
+
+    def export
+      send_data ContentExport.export.to_tar,
+        filename: "iron-content-#{Date.current}.tar",
+        type: "application/x-tar",
+        disposition: "attachment"
+    end
+
+    def new
+    end
+
+    def import
+      file = params[:content_file]
+
+      unless file.present?
+        redirect_to new_content_path, alert: "Please select a file to import"
+        return
+      end
+
+      archive = Archive.from_file(file)
+      result = ContentImport.import(archive)
+
+      if result.success?
+        redirect_to settings_path, notice: "Content imported successfully"
+      else
+        redirect_to new_content_path, alert: result.errors.join(". ")
+      end
+    end
+  end
+end

data/app/models/concerns/iron/instance_scoped.rb

@@ -0,0 +1,25 @@
+# Adds instance token to GlobalIDs to disambiguate between create and update operations
+# during import. When importing data:
+# - Same instance token + existing ID = UPDATE the existing record
+# - Different instance token + any ID = CREATE a new record
+# This allows safe data exchange between Iron instances without ID conflicts.
+module Iron
+  module InstanceScoped
+    extend ActiveSupport::Concern
+
+    def to_global_id(options = {})
+      super(options.merge(instance: instance))
+    end
+
+    def to_signed_global_id(options = {})
+      super(options.merge(instance: instance))
+    end
+
+    alias to_gid to_global_id
+    alias to_sgid to_signed_global_id
+
+    def instance
+      @instance ||= Current.account.instance_token
+    end
+  end
+end

data/app/models/iron/account.rb

@@ -2,6 +2,8 @@ module Iron
   class Account < ApplicationRecord
     include Joinable
 
+    has_secure_token :instance_token
+
     belongs_to :default_locale, class_name: "Iron::Locale"
 
     def self.clear_schema!

data/app/models/iron/archive.rb

@@ -0,0 +1,69 @@
+require "rubygems/package"
+require "stringio"
+
+module Iron
+  class Archive
+    attr_reader :files
+
+    def initialize(tar_content = nil)
+      @files = {}
+      extract_from_tar(tar_content) if tar_content
+    end
+
+    def self.from_file(file)
+      new(file.read)
+    end
+
+    def add_file(path, content)
+      @files[path] = content
+      self
+    end
+
+    def [](path)
+      @files[path]
+    end
+
+    def file_exists?(path)
+      @files.key?(path)
+    end
+
+    def file_paths
+      @files.keys
+    end
+
+    def to_tar
+      tarfile = StringIO.new
+
+      Gem::Package::TarWriter.new(tarfile) do |tar|
+        @files.each do |path, content|
+          content_string = content.is_a?(StringIO) ? content.string : content.to_s
+          tar.add_file_simple(path, 0644, content_string.bytesize) do |io|
+            io.write(content_string)
+          end
+        end
+      end
+
+      tarfile.string
+    end
+
+    def to_file(path)
+      File.open(path, "wb") { |f| f.write(to_tar) }
+    end
+
+    private
+
+      def extract_from_tar(tar_content)
+        tar_io = StringIO.new(tar_content)
+
+        Gem::Package::TarReader.new(tar_io) do |tar|
+          tar.each do |entry|
+            if entry.file?
+              @files[entry.full_name] = entry.read.force_encoding("UTF-8")
+            end
+          end
+        end
+      rescue => e
+        raise "Failed to extract tar archive: #{e.message}"
+      end
+  end
+end

data/app/models/iron/content_export.rb

@@ -0,0 +1,73 @@
+require "csv"
+
+module Iron
+  class ContentExport
+    def self.export
+      new.export
+    end
+
+    def initialize
+      @archive = Archive.new
+    end
+
+    def export
+      export_entries_by_content_type
+      export_files
+
+      @archive
+    end
+
+    private
+
+      def export_entries_by_content_type
+        ContentType.find_each do |content_type|
+          next if content_type.entries.empty?
+
+          @archive.add_file("content/#{content_type.handle}.csv", csv_for(content_type))
+        end
+      end
+
+      def csv_for(content_type)
+        CSV.generate do |csv|
+          csv << %w[entry_key locale path type value]
+
+          content_type.entries.find_each do |entry|
+            entry.to_csv_rows.each do |row|
+              csv << row
+            end
+          end
+        end
+      end
+
+      def export_files
+        collect_blob_ids.each do |blob_id|
+          blob = ActiveStorage::Blob.find_by(id: blob_id)
+          next unless blob
+
+          begin
+            blob.open do |file|
+              @archive.add_file("uploads/#{blob_id}", file.read)
+            end
+          rescue => e
+            Rails.logger.warn "Failed to export blob #{blob_id}: #{e.message}"
+          end
+        end
+      end
+
+      def collect_blob_ids
+        ids = Set.new
+
+        Fields::File.joins(file_attachment: :blob).pluck("active_storage_blobs.id").each do |id|
+          ids << id
+        end
+
+        ActionText::RichText.includes(:embeds_attachments).find_each do |rich_text|
+          rich_text.embeds_attachments.each do |attachment|
+            ids << attachment.blob.id if attachment.blob
+          end
+        end
+
+        ids
+      end
+  end
+end

data/app/models/iron/content_import/entry_builder.rb

@@ -0,0 +1,80 @@
+require "csv"
+
+module Iron
+  class ContentImport::EntryBuilder
+      def initialize(content_type, registry)
+        @content_type = content_type
+        @registry = registry
+      end
+
+      def ensure_entries_exist(csv_data)
+        entry_snapshots = parse_entry_snapshots(csv_data)
+
+        entry_snapshots.each do |_entry_gid, snapshot|
+          ensure_entry(snapshot)
+        end
+      end
+
+      private
+
+        def parse_entry_snapshots(csv_data)
+          snapshots = {}
+          return snapshots unless csv_data.present?
+
+          CSV.parse(csv_data, headers: true) do |row|
+            entry_key = row["entry_key"]
+            next if entry_key.blank?
+
+            snapshot = (snapshots[entry_key] ||= ContentImport::EntrySnapshot.new(entry_key))
+            add_row_to_snapshot(snapshot, row)
+          end
+
+          snapshots
+        end
+
+        def add_row_to_snapshot(snapshot, row)
+          path = row["path"]
+          return if path.blank?
+
+          if path == "/route"
+            snapshot.add_route(row["value"])
+          elsif path.start_with?("/fields/")
+            locale_code = row["locale"]
+            return unless locale_code.present?
+
+            field_snapshot = ContentImport::FieldSnapshot.new(
+              locale_code: locale_code,
+              path: path,
+              value: row["value"]
+            )
+            snapshot.add_field_snapshot(field_snapshot)
+          end
+        end
+
+        def ensure_entry(snapshot)
+          if snapshot.route.present?
+            existing_by_route = @content_type.entries.find_by(route: snapshot.route)
+            if existing_by_route
+              @registry.register_entry(snapshot.gid, existing_by_route)
+              return existing_by_route
+            end
+          end
+
+          existing_entry = @registry.find_entry(snapshot.gid)
+          # Only use the existing entry if it belongs to the correct content type
+          if existing_entry && existing_entry.content_type_id == @content_type.id
+            return existing_entry
+          end
+
+          new_entry = create_entry
+          @registry.register_entry(snapshot.gid, new_entry)
+          new_entry
+        end
+
+        def create_entry
+          entry = @content_type.entries.build
+          entry.save(validate: false)
+          entry
+        end
+  end
+end

data/app/models/iron/content_import/entry_snapshot.rb

@@ -0,0 +1,23 @@
+module Iron
+  class ContentImport::EntrySnapshot
+      attr_reader :gid, :route, :field_snapshots
+
+      def initialize(gid)
+        @gid = gid
+        @route = nil
+        @field_snapshots = []
+      end
+
+      def add_route(route)
+        @route = route
+      end
+
+      def add_field_snapshot(snapshot)
+        @field_snapshots << snapshot
+      end
+
+      def group_field_snapshots_by_locale
+        @field_snapshots.group_by(&:locale_code)
+      end
+  end
+end

data/app/models/iron/content_import/field_reconstructor.rb

@@ -0,0 +1,276 @@
+require "csv"
+
+module Iron
+  class ContentImport::FieldReconstructor
+      def initialize(content_type, registry, archive)
+        @content_type = content_type
+        @registry = registry
+        @archive = archive
+      end
+
+      def reconstruct_all(csv_data)
+        entry_snapshots = build_entry_snapshots(csv_data)
+
+        entry_snapshots.each do |entry_gid, snapshot|
+          reconstruct_entry(entry_gid, snapshot)
+        end
+      end
+
+      private
+
+        def build_entry_snapshots(csv_data)
+          snapshots = {}
+          return snapshots unless csv_data.present?
+
+          CSV.parse(csv_data, headers: true) do |row|
+            entry_key = row["entry_key"]
+            next if entry_key.blank?
+
+            snapshot = (snapshots[entry_key] ||= ContentImport::EntrySnapshot.new(entry_key))
+            populate_snapshot(snapshot, row)
+          end
+
+          snapshots
+        end
+
+        def populate_snapshot(snapshot, row)
+          path = row["path"]
+          return if path.blank?
+
+          if path == "/route"
+            snapshot.add_route(row["value"])
+          elsif path.start_with?("/fields/")
+            add_field_snapshot(snapshot, row)
+          end
+        end
+
+        def add_field_snapshot(snapshot, row)
+          locale_code = row["locale"]
+          return unless locale_code.present?
+
+          field_snapshot = ContentImport::FieldSnapshot.new(
+            locale_code: locale_code,
+            path: row["path"],
+            value: row["value"]
+          )
+          snapshot.add_field_snapshot(field_snapshot)
+        end
+
+        def reconstruct_entry(entry_gid, snapshot)
+          entry = @registry.find_entry(entry_gid)
+          return unless entry
+
+          update_entry_route(entry, snapshot.route) unless snapshot.route.nil?
+          reconstruct_entry_fields(entry, snapshot)
+        end
+
+        def update_entry_route(entry, route)
+          entry.update_columns(route: route)
+        end
+
+        def reconstruct_entry_fields(entry, snapshot)
+          snapshot.group_field_snapshots_by_locale.each do |locale_code, field_snapshots|
+            locale = Iron::Locale.find_by(code: locale_code)
+            next unless locale
+
+            reconstruct_fields_for_locale(entry, field_snapshots, locale)
+          end
+        end
+
+        def reconstruct_fields_for_locale(entry, field_snapshots, locale)
+          field_groups = field_snapshots
+            .select(&:field_path?)
+            .group_by(&:field_handle)
+
+          field_groups.each do |handle, snapshots|
+            definition = @content_type.field_definitions.find_by(handle: handle)
+            next unless definition
+
+            field = entry.find_or_build_field(definition, locale)
+            reconstruct_field(field, snapshots)
+          end
+        end
+
+        def reconstruct_field(field, snapshots)
+          case field
+          when Iron::Fields::TextField
+            field.value_string = snapshots.first.value
+          when Iron::Fields::TextArea
+            field.value_text = snapshots.first.value
+          when Iron::Fields::Number
+            field.value_decimal = snapshots.first.value.to_f if snapshots.first.value.present?
+          when Iron::Fields::Boolean
+            field.value_boolean = ActiveModel::Type::Boolean.new.cast(snapshots.first.value)
+          when Iron::Fields::Date
+            field.value_datetime = Time.zone.parse(snapshots.first.value) if snapshots.first.value.present?
+          when Iron::Fields::File
+            attach_file(field, snapshots.first.value)
+          when Iron::Fields::Reference
+            field.referenced_entry = @registry.find_entry(snapshots.first.value)
+          when Iron::Fields::RichTextArea
+            reconstruct_rich_text(field, snapshots)
+          when Iron::Fields::ReferenceList
+            reconstruct_reference_list(field, snapshots)
+          when Iron::Fields::Block
+            reconstruct_block(field, snapshots)
+          when Iron::Fields::BlockList
+            reconstruct_block_list(field, snapshots)
+          end
+
+          field.save!(validate: false)
+        rescue ArgumentError
+          # Handle date parsing errors
+          field.save!(validate: false)
+        end
+
+        def attach_file(field, blob_id)
+          return unless blob_id.present?
+
+          data = @archive["uploads/#{blob_id}"]
+          return unless data
+
+          field.file.attach(
+            io: StringIO.new(data),
+            filename: "imported-#{blob_id}",
+            content_type: "application/octet-stream"
+          )
+        end
+
+        def reconstruct_rich_text(field, snapshots)
+          html_snapshot = snapshots.find { |s| s.path.end_with?("/html") }
+
+          if html_snapshot&.value.present?
+            field.update!(rich_text: html_snapshot.value)
+          else
+            field.rich_text&.destroy
+          end
+        end
+
+        def reconstruct_reference_list(field, snapshots)
+          # Group snapshots by rank (the first segment after the field handle)
+          field.save!(validate: false) if field.new_record?
+
+          items = snapshots.filter_map do |snapshot|
+            segments = snapshot.field_segments
+            next if segments.length < 2
+
+            rank = segments.last
+            entry = @registry.find_entry(snapshot.value)
+            next unless entry
+
+            { rank:, entry: }
+          end
+
+          existing = field.references.index_by(&:rank)
+          kept_ids = []
+
+          items.each do |item|
+            reference = existing[item[:rank]] || field.references.build(rank: item[:rank])
+            reference.entry = item[:entry]
+            reference.save!
+            kept_ids << reference.id
+          end
+
+          field.references.where.not(id: kept_ids).destroy_all
+        end
+
+        def reconstruct_block(field, snapshots)
+          # Fields::Block IS the block - it doesn't have a separate block relation
+          # The field already has the block definition through field.definition
+
+          # Group snapshots by field handle
+          field_snapshots = snapshots.reject { |s| s.path.include?("/_block") }
+          reconstruct_block_fields(field, field_snapshots, field.locale)
+        end
+
+        def reconstruct_block_list(field, snapshots)
+          # Group snapshots by block rank
+          blocks_by_rank = {}
+
+          snapshots.each do |snapshot|
+            segments = snapshot.field_segments
+            next if segments.size < 2
+
+            rank = segments[1]
+            blocks_by_rank[rank] ||= []
+            blocks_by_rank[rank] << snapshot
+          end
+
+          # Clear all existing blocks first to avoid rank conflicts
+          field.blocks.destroy_all
+
+          blocks_by_rank.each do |rank, block_snapshots|
+            # Find block handle
+            block_snapshot = block_snapshots.find { |s| s.path.include?("/_block") }
+            block_handle = block_snapshot&.value
+            next unless block_handle
+
+            block_definition = Iron::BlockDefinition.find_by(handle: block_handle)
+            next unless block_definition
+
+            block = field.blocks.build(
+              rank: rank,
+              entry: field.entry,
+              locale: field.locale,
+              definition: block_definition
+            )
+
+            # Save the block first to establish it in the database
+            block.save!(validate: false)
+
+            # Then reconstruct its fields
+            field_snapshots = block_snapshots.reject { |s| s.path.include?("/_block") }
+            reconstruct_block_fields(block, field_snapshots, field.locale)
+          end
+        end
+
+        def reconstruct_block_fields(block, snapshots, locale)
+          # Group snapshots by field handle
+          field_groups = {}
+
+          snapshots.each do |snapshot|
+            field_handle = block_child_handle(block, snapshot)
+            next unless field_handle
+
+            field_groups[field_handle] ||= []
+            field_groups[field_handle] << snapshot
+          end
+
+          # Get the actual block definition
+          block_def = if block.respond_to?(:block_definition)
+            block.block_definition
+          else
+            block.definition
+          end
+
+          # Clear existing fields to avoid rank conflicts
+          block.fields.where(locale: locale).destroy_all
+
+          field_groups.each do |handle, field_snapshots|
+            definition = block_def.field_definitions.find_by(handle: handle)
+            next unless definition
+
+            field = block.fields.build(
+              type: definition.field_type,
+              entry: block.entry,
+              definition: definition,
+              locale: locale
+            )
+
+            reconstruct_field(field, field_snapshots)
+          end
+        end
+
+        def block_child_handle(block, snapshot)
+          relative_segments = snapshot.field_segments
+          block_path = block.send(:field_path)
+
+          if block_path.present?
+            block_segments = block_path.sub(%r{^/fields/}, "").split("/")
+            relative_segments = relative_segments.drop(block_segments.length)
+          end
+
+          relative_segments.first
+        end
+  end
+end

data/app/models/iron/content_import/field_snapshot.rb

@@ -0,0 +1,33 @@
+module Iron
+  class ContentImport::FieldSnapshot
+      attr_reader :locale_code, :path, :value
+
+      def initialize(locale_code:, path:, value:)
+        @locale_code = locale_code
+        @path = path
+        @value = value
+      end
+
+      def field_handle
+        return nil unless field_path?
+
+        segments[0]
+      end
+
+      def field_segments
+        return [] unless field_path?
+
+        segments
+      end
+
+      def field_path?
+        @path&.start_with?("/fields/")
+      end
+
+      private
+
+        def segments
+          @segments ||= @path.sub(%r{^/fields/}, "").split("/")
+        end
+  end
+end

data/app/models/iron/content_import/registry.rb

@@ -0,0 +1,32 @@
+module Iron
+  class ContentImport::Registry
+      def initialize
+        @entries_by_original_gid = {}
+      end
+
+      def register_entry(original_gid, entry)
+        @entries_by_original_gid[original_gid] = entry
+        @entries_by_original_gid[entry.to_gid.to_s] = entry
+      end
+
+      def find_entry(gid_string)
+        return nil if gid_string.blank?
+
+        cached_entry = @entries_by_original_gid[gid_string]
+        return cached_entry if cached_entry
+
+        locate_existing_entry(gid_string)
+      end
+
+      private
+
+        def locate_existing_entry(gid_string)
+          entry = ::GlobalID::Locator.locate(gid_string)
+          return nil unless entry.is_a?(Iron::Entry)
+
+          @entries_by_original_gid[gid_string] = entry
+        rescue ActiveRecord::RecordNotFound
+          nil
+        end
+  end
+end