iron-cms 0.1.2 → 0.2.0

data/app/models/iron/schema_importer/replace_strategy.rb

@@ -0,0 +1,51 @@
+module Iron
+  class SchemaImporter::ReplaceStrategy < SchemaImporter::ImportStrategy
+    def import_block_definition(row)
+      BlockDefinition.create!(
+        handle: row["handle"],
+        name: row["name"],
+        description: row["description"]
+      )
+    end
+
+    def import_content_type(row)
+      content_type_class(row["type"]).create!(
+        handle: row["handle"],
+        name: row["name"],
+        description: row["description"],
+        icon: row["icon"],
+        web_publishing_enabled: row["web_publishing_enabled"] == "true",
+        base_path: row["base_path"]
+      )
+    end
+
+    def import_field_definition(row)
+      raise "Field type is required" unless row["type"].present?
+      return unless row["parent_type"].present? && row["parent_handle"].present? && row["handle"].present?
+
+      parent = find_parent(row["parent_type"], row["parent_handle"])
+      return unless parent
+
+      parent.field_definitions.find_by(handle: row["handle"])&.destroy!
+
+      klass = field_definition_class(row["type"])
+      attributes = {
+        schemable: parent,
+        handle: row["handle"],
+        name: row["name"],
+        rank: row["rank"],
+        metadata: parse_metadata(row["metadata"])
+      }
+
+      if klass <= FieldDefinitions::Block || klass <= FieldDefinitions::BlockList
+        attributes[:supported_block_definition_ids] = parse_supported_block_definitions(row["supported_block_definitions"]).pluck(:id)
+      end
+
+      if klass <= FieldDefinitions::Reference || klass <= FieldDefinitions::ReferenceList
+        attributes[:supported_content_type_ids] = parse_supported_content_types(row["supported_content_types"]).pluck(:id)
+      end
+
+      klass.create!(attributes)
+    end
+  end
+end

data/app/models/iron/schema_importer/safe_strategy.rb

@@ -0,0 +1,55 @@
+module Iron
+  class SchemaImporter::SafeStrategy < SchemaImporter::ImportStrategy
+    def import_block_definition(row)
+      return if BlockDefinition.exists?(handle: row["handle"])
+
+      BlockDefinition.create!(
+        handle: row["handle"],
+        name: row["name"],
+        description: row["description"]
+      )
+    end
+
+    def import_content_type(row)
+      return if ContentType.exists?(handle: row["handle"])
+
+      content_type_class(row["type"]).create!(
+        handle: row["handle"],
+        name: row["name"],
+        description: row["description"],
+        icon: row["icon"],
+        web_publishing_enabled: row["web_publishing_enabled"] == "true",
+        base_path: row["base_path"]
+      )
+    end
+
+    def import_field_definition(row)
+      raise "Field type is required" unless row["type"].present?
+      return unless row["parent_type"].present? && row["parent_handle"].present? && row["handle"].present?
+
+      parent = find_parent(row["parent_type"], row["parent_handle"])
+      return unless parent
+
+      return if parent.field_definitions.exists?(handle: row["handle"])
+
+      klass = field_definition_class(row["type"])
+      attributes = {
+        schemable: parent,
+        handle: row["handle"],
+        name: row["name"],
+        rank: row["rank"],
+        metadata: parse_metadata(row["metadata"])
+      }
+
+      if klass <= FieldDefinitions::Block || klass <= FieldDefinitions::BlockList
+        attributes[:supported_block_definition_ids] = parse_supported_block_definitions(row["supported_block_definitions"]).pluck(:id)
+      end
+
+      if klass <= FieldDefinitions::Reference || klass <= FieldDefinitions::ReferenceList
+        attributes[:supported_content_type_ids] = parse_supported_content_types(row["supported_content_types"]).pluck(:id)
+      end
+
+      klass.create!(attributes)
+    end
+  end
+end

data/app/models/iron/schema_importer.rb

@@ -11,16 +11,16 @@ module Iron
     end
 
     def initialize(file, mode: "merge")
+      raise ArgumentError, "Missing import file" unless file.present?
+      raise ArgumentError, "Invalid import mode: #{mode}. Must be one of: #{IMPORT_MODES.join(', ')}" unless IMPORT_MODES.include?(mode)
+
       @file = file
       @mode = mode.to_s
       @errors = []
-
-      validate_mode!
+      @strategy = build_strategy(mode)
     end
 
     def import
-      return ImportResult.new(false, errors) unless valid?
-
       ActiveRecord::Base.transaction do
         Account.clear_schema! if mode == "replace"
 
@@ -31,205 +31,45 @@ module Iron
           return ImportResult.new(false, errors)
         end
 
-        import_block_definitions(archive["block_definitions.csv"])
-        import_content_types(archive["content_types.csv"])
-        import_field_definitions(archive["field_definitions.csv"])
-
-        update_content_type_references(archive["content_types.csv"])
-
-        ImportResult.new(true, [])
-      end
-    rescue StandardError => e
-      errors << "Import failed: #{e.message}"
-      ImportResult.new(false, errors)
-    end
-
-    private
-
-      def valid?
-        validate_file_presence
-        errors.empty?
-      end
-
-      def validate_mode!
-        unless IMPORT_MODES.include?(mode)
-          raise ArgumentError, "Invalid import mode: #{mode}. Must be one of: #{IMPORT_MODES.join(', ')}"
-        end
-      end
-
-      def validate_file_presence
-        errors << "No file provided" unless file
-      end
-
-      def import_block_definitions(csv_content)
-        return unless csv_content
-
-        CSV.parse(csv_content, headers: true) do |row|
-          handle = row["handle"]
-          next unless handle.present?
-
-          case mode
-          when "merge"
-            block_def = BlockDefinition.find_or_initialize_by(handle: handle)
-            block_def.assign_attributes(
-              name: row["name"],
-              description: row["description"]
-            )
-            block_def.save!
-          when "replace"
-            BlockDefinition.create!(
-              handle: handle,
-              name: row["name"],
-              description: row["description"]
-            )
-          when "safe"
-            next if BlockDefinition.exists?(handle: handle)
-
-            BlockDefinition.create!(
-              handle: handle,
-              name: row["name"],
-              description: row["description"]
-            )
+        if archive["block_definitions.csv"]
+          CSV.parse(archive["block_definitions.csv"], headers: true) do |row|
+            next unless row["handle"].present?
+            @strategy.import_block_definition(row)
           end
         end
-      end
 
-      def import_content_types(csv_content)
-        return unless csv_content
-
-        CSV.parse(csv_content, headers: true) do |row|
-          handle = row["handle"]
-          next unless handle.present?
-
-          case mode
-          when "merge"
-            content_type = ContentType.find_or_initialize_by(handle: handle)
-            update_content_type(content_type, row)
-          when "replace"
-            content_type = build_content_type(row)
-            content_type.save!
-          when "safe"
-            next if ContentType.exists?(handle: handle)
-
-            content_type = build_content_type(row)
-            content_type.save!
+        if archive["content_types.csv"]
+          CSV.parse(archive["content_types.csv"], headers: true) do |row|
+            next unless row["handle"].present?
+            @strategy.import_content_type(row)
           end
         end
-      end
-
-      def import_field_definitions(csv_content)
-        return unless csv_content
-
-        CSV.parse(csv_content, headers: true) do |row|
-          parent_type = row["parent_type"]
-          parent_handle = row["parent_handle"]
-          handle = row["handle"]
 
-          next unless parent_type.present? && parent_handle.present? && handle.present?
-
-          parent = find_parent(parent_type, parent_handle)
-          next unless parent
-
-          case mode
-          when "merge"
-            field_def = parent.field_definitions.find_or_initialize_by(handle: handle)
-            update_field_definition(field_def, row)
-          when "replace"
-            field_def = build_field_definition(parent, row)
-            field_def.save!
-          when "safe"
-            next if parent.field_definitions.exists?(handle: handle)
-
-            field_def = build_field_definition(parent, row)
-            field_def.save!
+        if archive["field_definitions.csv"]
+          CSV.parse(archive["field_definitions.csv"], headers: true) do |row|
+            @strategy.import_field_definition(row)
           end
         end
-      end
-
-      def find_parent(parent_type, parent_handle)
-        case parent_type
-        when "content_type"
-          ContentType.find_by(handle: parent_handle)
-        when "block"
-          BlockDefinition.find_by(handle: parent_handle)
-        end
-      end
-
-      def build_content_type(row)
-        klass = case row["type"]
-        when "single" then ContentTypes::Single
-        when "collection" then ContentTypes::Collection
-        else ContentType
-        end
-
-        klass.new(
-          handle: row["handle"],
-          name: row["name"],
-          description: row["description"],
-          icon: row["icon"],
-          web_publishing_enabled: row["web_publishing_enabled"] == "true",
-          base_path: row["base_path"]
-        )
-      end
-
-      def update_content_type(content_type, row)
-        content_type.assign_attributes(
-          name: row["name"],
-          description: row["description"],
-          icon: row["icon"],
-          web_publishing_enabled: row["web_publishing_enabled"] == "true",
-          base_path: row["base_path"]
-        )
-
-        # Update type if changed
-        if row["type"] && content_type.type != "Iron::ContentTypes::#{row['type'].camelize}"
-          content_type.type = "Iron::ContentTypes::#{row['type'].camelize}"
-        end
-
-        content_type.save!
-      end
-
-      def build_field_definition(parent, row)
-        klass = "Iron::FieldDefinitions::#{row['type'].camelize}".constantize
 
-        field_def = klass.new(
-          schemable: parent,
-          handle: row["handle"],
-          name: row["name"],
-          rank: row["rank"],
-          metadata: parse_metadata(row["metadata"])
-        )
-
-        # Set supported block definitions before saving
-        set_supported_block_definitions(field_def, row["supported_block_definitions"])
+        update_content_type_references(archive["content_types.csv"])
 
-        field_def
+        ImportResult.new(true, [])
       end
+    rescue StandardError => e
+      errors << "Import failed: #{e.message}"
+      ImportResult.new(false, errors)
+    end
 
-      def update_field_definition(field_def, row)
-        field_def.assign_attributes(
-          name: row["name"],
-          rank: row["rank"],
-          metadata: parse_metadata(row["metadata"])
-        )
+    private
 
-        # Update type if changed
-        if row["type"] && field_def.type != "Iron::FieldDefinitions::#{row['type'].camelize}"
-          field_def.type = "Iron::FieldDefinitions::#{row['type'].camelize}"
+      def build_strategy(mode)
+        case mode.to_s
+        when "merge" then SchemaImporter::MergeStrategy.new
+        when "replace" then SchemaImporter::ReplaceStrategy.new
+        when "safe" then SchemaImporter::SafeStrategy.new
+        else
+          raise ArgumentError, "Invalid import mode: #{mode}"
         end
-
-        # Set supported block definitions before saving
-        set_supported_block_definitions(field_def, row["supported_block_definitions"])
-
-        field_def.save!
-      end
-
-      def parse_metadata(metadata_string)
-        return {} if metadata_string.blank?
-
-        JSON.parse(metadata_string)
-      rescue JSON::ParserError
-        {}
       end
 
       def update_content_type_references(content_types_csv)
@@ -252,16 +92,6 @@ module Iron
         end
       end
 
-      def set_supported_block_definitions(field_def, supported_handles_string)
-        return unless supported_handles_string.present?
-        return unless field_def.respond_to?(:supported_block_definitions)
-
-        handles = supported_handles_string.split("|")
-        block_definitions = BlockDefinition.where(handle: handles)
-
-        field_def.supported_block_definitions = block_definitions
-      end
-
       class ImportResult
         attr_reader :errors
 

data/app/views/iron/contents/new.html.erb

@@ -0,0 +1,34 @@
+<% content_for :title, "Import Content" %>
+
+<div class="">
+  <%= back_button_to "Settings", settings_path %>
+  <h1 class="page-title">Import Content</h1>
+  <p class="mt-2 text-sm text-stone-500">Upload a content archive exported from another Iron instance.</p>
+
+  <%= form_with url: import_content_path, multipart: true, class: "mt-8 max-w-2xl", data: { turbo: false } do |form| %>
+    <div class="field-group">
+      <div class="field">
+        <%= form.label :content_file, "Content Archive" %>
+        <div>
+          <%= form.file_field :content_file,
+              accept: ".tar",
+              required: true,
+              class: "input" %>
+          <p class="mt-2 text-sm text-stone-500">Select a .tar file exported using Iron's content export.</p>
+        </div>
+      </div>
+
+      <div class="field">
+        <label class="text-sm font-medium text-stone-700">Import behaviour</label>
+        <p class="text-sm text-stone-500 mt-1">
+          Entries with matching IDs and instance tokens are updated. Other records are created.
+        </p>
+      </div>
+    </div>
+
+    <div class="mt-6 flex items-center gap-x-3">
+      <%= form.submit "Import Content", class: "btn" %>
+      <%= link_to "Cancel", settings_path, class: "btn", data: { variant: "plain" } %>
+    </div>
+  <% end %>
+</div>

data/app/views/iron/settings/show.html.erb

@@ -35,4 +35,23 @@
       </div>
     <% end %>
   </div>
+
+  <div class="bg-white dark:bg-stone-800/50 rounded-lg shadow-sm p-6 max-w-96">
+    <h2 class="text-lg font-semibold mb-4">Content Management</h2>
+    <p class="text-sm text-stone-600 dark:text-stone-400 mb-4">
+      Export content entries and their files or import an archive from another instance.
+    </p>
+    <div class="flex flex-col gap-2">
+      <%= link_to "Export Content",
+        export_content_path,
+        class: "btn",
+        data: {
+          turbo: false,
+        } %>
+      <%= link_to "Import Content",
+        new_content_path,
+        class: "btn",
+        data: { variant: "secondary" } %>
+    </div>
+  </div>
 </div>

data/config/routes.rb

@@ -22,6 +22,11 @@ Iron::Engine.routes.draw do
     post :import, on: :member
   end
 
+  resource :content, only: [ :new ] do
+    get :export, on: :collection
+    post :import, on: :collection
+  end
+
   resources :block_definitions do
     resources :field_definitions, shallow: true, module: :block_definitions
   end

data/db/migrate/20250908203158_add_instance_token_to_iron_accounts.rb

@@ -0,0 +1,6 @@
+class AddInstanceTokenToIronAccounts < ActiveRecord::Migration[8.0]
+  def change
+    add_column :iron_accounts, :instance_token, :string
+    add_index :iron_accounts, :instance_token, unique: true
+  end
+end

data/lib/iron/engine.rb

@@ -31,6 +31,15 @@ module Iron
       app.config.active_storage.analyzers.prepend Iron::ImageAnalyzer
     end
 
+    initializer "iron.global_id_locator" do |app|
+      app.config.after_initialize do
+        global_id_app = ::GlobalID.app || ::Rails.application.config.try(:global_id)&.app
+        next unless global_id_app
+
+        ::GlobalID::Locator.use(global_id_app, Iron::GlobalID::InstanceScopedLocator.new)
+      end
+    end
+
     config.to_prepare do
       ActionView::Base.include(Module.new do
         def attachment_url(attachment, **options)

data/lib/iron/global_id/instance_scoped_locator.rb

@@ -0,0 +1,29 @@
+require "globalid"
+
+module Iron
+  module GlobalID
+    class InstanceScopedLocator < ::GlobalID::Locator::UnscopedLocator
+      def locate(gid, options = {})
+        return unless instance_matches?(gid)
+
+        super
+      end
+
+      def locate_many(gids, options = {})
+        filtered_gids = gids.select { |candidate| instance_matches?(candidate) }
+        return [] if filtered_gids.empty?
+
+        super(filtered_gids, options)
+      end
+
+      private
+
+        def instance_matches?(gid)
+          instance_token = gid.params[:instance]
+          return true if instance_token.blank?
+
+          Current.account&.instance_token == instance_token
+        end
+    end
+  end
+end

data/lib/iron/version.rb

@@ -1,3 +1,3 @@
 module Iron
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/lib/iron-cms.rb

@@ -1 +1 @@
-require "iron"
+require "iron"

data/lib/iron.rb

@@ -2,6 +2,7 @@ require "iron/version"
 require "iron/engine"
 require "iron/cva"
 require "iron/sdk"
+require "iron/global_id/instance_scoped_locator"
 
 module Iron
   # Your code goes here...

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iron-cms
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Massimo De Marchi
@@ -198,6 +198,7 @@ files:
 - app/controllers/iron/blocks_controller.rb
 - app/controllers/iron/content_types/field_definitions_controller.rb
 - app/controllers/iron/content_types_controller.rb
+- app/controllers/iron/contents_controller.rb
 - app/controllers/iron/entries_controller.rb
 - app/controllers/iron/field_definitions_controller.rb
 - app/controllers/iron/first_runs_controller.rb
@@ -239,11 +240,21 @@ files:
 - app/mailers/iron/application_mailer.rb
 - app/mailers/passwords_mailer.rb
 - app/models/concerns/iron/csv_serializable.rb
+- app/models/concerns/iron/instance_scoped.rb
 - app/models/iron/account.rb
 - app/models/iron/account/joinable.rb
 - app/models/iron/application_record.rb
+- app/models/iron/archive.rb
 - app/models/iron/block_definition.rb
 - app/models/iron/block_definition/portable.rb
+- app/models/iron/content_export.rb
+- app/models/iron/content_import.rb
+- app/models/iron/content_import/entry_builder.rb
+- app/models/iron/content_import/entry_snapshot.rb
+- app/models/iron/content_import/field_reconstructor.rb
+- app/models/iron/content_import/field_snapshot.rb
+- app/models/iron/content_import/registry.rb
+- app/models/iron/content_import/session.rb
 - app/models/iron/content_type.rb
 - app/models/iron/content_type/field_queryable.rb
 - app/models/iron/content_type/portable.rb
@@ -254,12 +265,14 @@ files:
 - app/models/iron/current.rb
 - app/models/iron/entry.rb
 - app/models/iron/entry/deep_validation.rb
+- app/models/iron/entry/portable.rb
 - app/models/iron/entry/presentable.rb
 - app/models/iron/entry/schemable.rb
 - app/models/iron/entry/titlable.rb
 - app/models/iron/entry/web_publishable.rb
 - app/models/iron/field.rb
 - app/models/iron/field/belongs_to_entry.rb
+- app/models/iron/field/portable.rb
 - app/models/iron/field_definition.rb
 - app/models/iron/field_definition/portable.rb
 - app/models/iron/field_definitions/block.rb
@@ -291,6 +304,10 @@ files:
 - app/models/iron/schema_archive.rb
 - app/models/iron/schema_exporter.rb
 - app/models/iron/schema_importer.rb
+- app/models/iron/schema_importer/import_strategy.rb
+- app/models/iron/schema_importer/merge_strategy.rb
+- app/models/iron/schema_importer/replace_strategy.rb
+- app/models/iron/schema_importer/safe_strategy.rb
 - app/models/iron/session.rb
 - app/models/iron/user.rb
 - app/models/iron/user/role.rb
@@ -308,6 +325,7 @@ files:
 - app/views/iron/content_types/index.html.erb
 - app/views/iron/content_types/new.html.erb
 - app/views/iron/content_types/show.html.erb
+- app/views/iron/contents/new.html.erb
 - app/views/iron/entries/_entry.html.erb
 - app/views/iron/entries/_entry_option.html.erb
 - app/views/iron/entries/_form.html.erb
@@ -390,6 +408,7 @@ files:
 - db/migrate/20250601080146_add_icon_to_iron_content_types.rb
 - db/migrate/20250609091605_add_web_publishing_to_iron_content_types.rb
 - db/migrate/20250609091813_add_route_to_iron_entries.rb
+- db/migrate/20250908203158_add_instance_token_to_iron_accounts.rb
 - lib/generators/iron/pages/pages_generator.rb
 - lib/generators/iron/pages/templates/pages_controller.rb
 - lib/generators/iron/pages/templates/show.html.erb
@@ -399,6 +418,7 @@ files:
 - lib/iron.rb
 - lib/iron/cva.rb
 - lib/iron/engine.rb
+- lib/iron/global_id/instance_scoped_locator.rb
 - lib/iron/image_analyzer.rb
 - lib/iron/lexorank.rb
 - lib/iron/lexorank/exceptions.rb