iron-cms 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d060f858dd0cc96cf89c5c0195a6073813325c20f324d80d164ee11f4d299b15
-  data.tar.gz: 6856bd27d67600a115fa00926e4be52bc94357fd61eef6cda694b0074f545c68
+  metadata.gz: 6f8165107a118a6f3a8dcefe95984760653d8baf16f96653642382fc73ce8aca
+  data.tar.gz: 7143fd0c4f78a53e4b945f52005cc1f68e225674667f0f6a8bce8dcb8b77a02d
 SHA512:
-  metadata.gz: 3aa25a33717ca01a28a7f286beefc4fd2dc2486621533922afe660ccb2dd141dfe2dd2316735747896c3f5ae2bb322a3e91f82b06cae01e1da7b9e0e7e8930ad
-  data.tar.gz: 4d33417da4ec5a717ad5c1e3430662117e42408917a7d0587861db28e6a7d15f0618ac3fb321442de942b92bff5532bf6ae4dfb9d60ba9edd7806213cfaf038a
+  metadata.gz: e09696ccbfb17bf2a82d515e7297f097a4a6fbdeb8a30626bf1cb1e44818ae9f55f260fa6b7e04acce6707d1d212305318cddf6db545f62d04b37d919191c73f
+  data.tar.gz: be54e07e53ca096cb56e66887eab33085f76545716a61dfa7976866303f224867d9766eceaa338a65ecd3182d5b2b7af2003226d98c52d64dd17a68b912cc7e3

data/README.md

@@ -96,37 +96,36 @@ For cases where you need a basic responsive image without format optimization:
 
 This generates a standard `<img>` with srcset but without modern format variants.
 
-### Testing
+### Development Seeding
 
-Iron provides test fixtures to populate your test database with CMS schema and content, eliminating the need to stub the SDK in your tests.
+Iron provides a seeding mechanism to snapshot and restore CMS schema and content, making it easy for teammates to get a consistent development database.
 
-#### Generating Fixtures
+#### Creating a seed
 
-Generate test fixtures from your development database (or production if you prefer):
+After setting up your content types and sample content via the admin UI:
 
 ```bash
-bin/rails iron:fixtures:generate
+bin/rails iron:seed:dump
 ```
 
-This creates two files in `test/fixtures/iron/`:
+This exports the full CMS state to `db/seeds/iron.zip`. Commit this file to your repository.
 
-- `schema.tar.gz` - Content types, field definitions, and block definitions
-- `content.tar.gz` - All entries and their field data
+#### Loading a seed
 
-Regenerate these fixtures whenever you make changes to your CMS schema or content that you want reflected in tests.
-
-#### Using Fixtures in Tests
-
-Load the fixtures in your `test/test_helper.rb`:
+Add this to your `db/seeds.rb`:
 
 ```ruby
-class ActiveSupport::TestCase
-  fixtures :all
-  Iron::TestFixtures.load
-end
+Iron::Seed.load
 ```
 
-The fixtures are loaded once at the start of your test suite. Rails' transactional tests provide test isolation by rolling back changes after each test.
+Then `rails db:prepare` (or `rails db:seed`) will automatically bootstrap the CMS when the database is empty. Loading is skipped if content types already exist.
+
+#### Admin credentials
+
+The seed creates a default admin user during loading. Configure via environment variables:
+
+- `IRON_SEED_EMAIL` (default: `admin@example.com`)
+- `IRON_SEED_PASSWORD` (default: `password`)
 
 ## System Requirements
 

data/app/assets/builds/iron.css

@@ -3429,6 +3429,9 @@
   .opacity-0 {
     opacity: 0%;
   }
+  .opacity-50 {
+    opacity: 50%;
+  }
   .shadow {
     --tw-shadow: 0 1px 3px 0 var(--tw-shadow-color, rgb(0 0 0 / 0.1)), 0 1px 2px -1px var(--tw-shadow-color, rgb(0 0 0 / 0.1));
     box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);

data/app/controllers/concerns/iron/authentication.rb

@@ -33,7 +33,8 @@ module Iron
 
 
       def resume_session
-        Current.session ||= find_session_by_cookie
+        session = find_session_by_cookie
+        Current.session ||= session if session&.user&.active?
       end
 
       def find_session_by_cookie

data/app/controllers/iron/passwords_controller.rb

@@ -9,7 +9,7 @@ module Iron
     end
 
     def create
-      if user = User.find_by(email_address: params[:email_address])
+      if user = User.active.find_by(email_address: params[:email_address])
         Iron::PasswordsMailer.reset(user).deliver_later
       end
 
@@ -36,6 +36,7 @@ module Iron
 
       def set_user_by_token
         @user = User.find_by_password_reset_token!(params[:token])
+        redirect_to new_password_url, alert: t("iron.passwords.alerts.reset_link_invalid") unless @user.active?
       rescue ActiveSupport::MessageVerifier::InvalidSignature
         redirect_to new_password_url, alert: t("iron.passwords.alerts.reset_link_invalid")
       end

data/app/controllers/iron/sessions/transfers_controller.rb

@@ -9,7 +9,7 @@ module Iron
       end
 
       def update
-        if user = User.find_by_transfer_id(params[:id])
+        if (user = User.find_by_transfer_id(params[:id])) && user.active?
           start_new_session_for user
           redirect_to after_authentication_url
         else

data/app/controllers/iron/sessions_controller.rb

@@ -10,7 +10,7 @@ module Iron
     end
 
     def create
-      if user = User.authenticate_by(params.permit(:email_address, :password))
+      if user = User.active.authenticate_by(params.permit(:email_address, :password))
         start_new_session_for user
         redirect_to after_authentication_url
       else

data/app/controllers/iron/users/reactivations_controller.rb

@@ -0,0 +1,18 @@
+module Iron
+  module Users
+    class ReactivationsController < ApplicationController
+      before_action :set_user
+      before_action :ensure_can_administer
+
+      def update
+        @user.reactivate
+        redirect_to @user, notice: t("iron.users.notifications.reactivated")
+      end
+
+      private
+        def set_user
+          @user = User.find(params.expect(:user_id))
+        end
+    end
+  end
+end

data/app/controllers/iron/users/roles_controller.rb

@@ -14,7 +14,7 @@ module Iron
 
       private
         def set_user
-          @user = User.find(params.expect(:user_id))
+          @user = User.active.find(params.expect(:user_id))
         end
     end
   end

data/app/controllers/iron/users_controller.rb

@@ -8,7 +8,8 @@ module Iron
     before_action :ensure_can_administer, only: %i[ index destroy ]
 
     def index
-      @users = User.all
+      @users = User.active
+      @deactivated_users = User.where(active: false)
     end
 
     def new
@@ -31,8 +32,8 @@ module Iron
     end
 
     def destroy
-      if @user.destroy
-        redirect_back fallback_location: users_path, notice: t("iron.users.notifications.removed"), status: :see_other
+      if @user.deactivate
+        redirect_to users_path, notice: t("iron.users.notifications.removed"), status: :see_other
       else
         redirect_back fallback_location: users_path, alert: @user.errors.full_messages.to_sentence, status: :see_other
       end
@@ -40,7 +41,7 @@ module Iron
 
     private
       def set_user
-        @user = User.find(params.expect(:id))
+        @user = User.active.find(params.expect(:id))
       end
 
       def join_params

data/app/models/iron/account/export.rb

@@ -17,70 +17,12 @@ module Iron
       def perform
         raise ArgumentError, "Nothing selected to export" unless include_schema? || include_content?
 
-        zipfile = generate_zip
-        file.attach(
-          io: File.open(zipfile.path),
-          filename: "iron-export-#{id}.zip",
-          content_type: "application/zip"
-        )
+        zipfile = Tempfile.new([ "export", ".zip" ])
+        Exporter.new(zipfile.path, include_schema: include_schema?, include_content: include_content?).export
+        file.attach(io: File.open(zipfile.path), filename: "iron-export-#{id}.zip", content_type: "application/zip")
       ensure
         zipfile&.close
         zipfile&.unlink
       end
-
-      def generate_zip
-        Tempfile.new([ "export", ".zip" ]).tap do |tempfile|
-          Zip::File.open(tempfile.path, create: true) do |zip|
-            add_schema_to_zip(zip) if include_schema?
-            add_content_to_zip(zip) if include_content?
-          end
-        end
-      end
-
-      def add_schema_to_zip(zip)
-        zip.get_output_stream("schema.json") { |f| f.write(export_schema_json) }
-      end
-
-      def add_content_to_zip(zip)
-        exportable_entries.find_each do |entry|
-          path = "entries/#{entry.content_type.handle}/#{entry.id}.json"
-          zip.get_output_stream(path) { |f| f.write(entry.export_json) }
-
-          entry.export_attachments.each do |attachment|
-            zip.get_output_stream("files/#{attachment[:path]}", compression_method: Zip::Entry::STORED) do |f|
-              attachment[:blob].download { |chunk| f.write(chunk) }
-            end
-          rescue ActiveStorage::FileNotFoundError
-            # Skip missing files
-          end
-        end
-      end
-
-      def export_schema_json
-        JSON.pretty_generate(
-          version: "1.0",
-          exported_at: Time.current.iso8601,
-          block_definitions: export_block_definitions,
-          content_types: export_content_types
-        )
-      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)
-      end
-
-      def exportable_entries
-        Entry.includes(:content_type, :creator, fields: [ :locale, :definition ])
-      end
   end
 end

data/app/models/iron/account/import.rb

@@ -18,190 +18,12 @@ module Iron
       def perform
         raise ArgumentError, "Nothing selected to import" unless include_schema? || include_content?
 
-        import_from_zip
-      end
-
-      def import_from_zip
         Tempfile.create([ "import", ".zip" ]) do |tempfile|
           tempfile.binmode
           tempfile.write(file.download)
           tempfile.rewind
 
-          Zip::File.open(tempfile.path) do |zip|
-            @zip = zip
-            @files_dir = extract_files_to_temp_dir(zip)
-
-            import_schema_from_zip if include_schema?
-            import_content_from_zip if include_content?
-          ensure
-            FileUtils.rm_rf(@files_dir) if @files_dir
-          end
-        end
-      end
-
-      def extract_files_to_temp_dir(zip)
-        dir = Dir.mktmpdir("iron-import")
-        zip.glob("files/**/*").each do |entry|
-          next if entry.directory?
-
-          path = File.join(dir, entry.name.sub("files/", ""))
-          FileUtils.mkdir_p(File.dirname(path))
-          entry.extract(path)
-        end
-        dir
-      end
-
-      def import_schema_from_zip
-        return unless @zip.find_entry("schema.json")
-
-        schema_json = @zip.read("schema.json")
-        schema = parse_json(schema_json)
-        raise ArgumentError, "Invalid schema JSON format" unless schema
-
-        ActiveRecord::Base.transaction do
-          import_block_definitions(schema[:block_definitions] || [])
-          import_content_types(schema[:content_types] || [])
-          resolve_content_type_references(schema[:content_types] || [])
-        end
-      end
-
-      def import_content_from_zip
-        ActiveRecord::Base.transaction do
-          id_mapping = {}
-          entries_data = []
-
-          # First pass: read all entry files and create entries
-          @zip.glob("entries/**/*.json").each do |zip_entry|
-            attrs = parse_json(zip_entry.get_input_stream.read)
-            next unless attrs
-
-            entries_data << attrs
-            entry = Entry.import_from_attributes(attrs, @files_dir)
-            id_mapping[attrs[:id]] = entry if entry
-          end
-
-          # Second pass: resolve references
-          resolve_references(entries_data, id_mapping)
-        end
-      end
-
-      def resolve_references(entries_data, id_mapping)
-        entries_data.each do |attrs|
-          entry = id_mapping[attrs[:id]]
-          next unless entry
-
-          (attrs[:fields] || {}).each do |locale_code, field_data|
-            locale = Locale.find_by(code: locale_code.to_s)
-            next unless locale
-
-            resolve_references_in_fields(entry, locale, field_data, id_mapping)
-          end
-        end
-      end
-
-      def resolve_references_in_fields(entry, locale, fields_data, id_mapping, parent: nil)
-        fields_data.each do |handle, value_data|
-          next unless value_data.is_a?(Hash)
-
-          case value_data[:type]
-          when "reference"
-            resolve_reference_field(entry, locale, handle.to_s, value_data[:value], id_mapping, parent: parent)
-          when "reference_list"
-            resolve_reference_list_field(entry, locale, handle.to_s, value_data[:value], id_mapping, parent: parent)
-          when "block"
-            resolve_references_in_block(entry, locale, handle.to_s, value_data, id_mapping, parent: parent)
-          when "block_list"
-            resolve_references_in_block_list(entry, locale, handle.to_s, value_data, id_mapping, parent: parent)
-          end
-        end
-      end
-
-      def resolve_references_in_block(entry, locale, handle, value_data, id_mapping, parent: nil)
-        block_field = find_field(entry, locale, handle, parent)
-        return unless block_field
-
-        resolve_references_in_fields(entry, locale, value_data[:fields] || {}, id_mapping, parent: block_field)
-      end
-
-      def resolve_references_in_block_list(entry, locale, handle, value_data, id_mapping, parent: nil)
-        block_list_field = find_field(entry, locale, handle, parent)
-        return unless block_list_field
-
-        # Reload blocks and get them in rank order (matching import order)
-        ordered_blocks = block_list_field.blocks.reload.sort_by(&:rank)
-
-        (value_data[:value] || []).each_with_index do |block_data, index|
-          block = ordered_blocks[index]
-          next unless block
-
-          resolve_references_in_fields(entry, locale, block_data[:fields] || {}, id_mapping, parent: block)
-        end
-      end
-
-      def find_field(entry, locale, handle, parent)
-        # Reload associations to get freshly persisted fields from the first pass
-        fields = parent&.fields&.reload || entry.fields.reload
-        definition_scope = parent.is_a?(Fields::Block) ? parent.block_definition.field_definitions : entry.content_type.field_definitions
-        definition = definition_scope.find_by(handle: handle)
-        return unless definition
-
-        fields.find { |f| f.definition_id == definition.id && f.locale_id == locale.id }
-      end
-
-      def resolve_reference_field(entry, locale, handle, old_entry_id, id_mapping, parent: nil)
-        return unless old_entry_id
-
-        referenced_entry = id_mapping[old_entry_id]
-        return unless referenced_entry
-
-        field = find_field(entry, locale, handle, parent)
-        return unless field
-
-        field.update!(referenced_entry: referenced_entry)
-      end
-
-      def resolve_reference_list_field(entry, locale, handle, old_entry_ids, id_mapping, parent: nil)
-        return unless old_entry_ids.is_a?(Array)
-
-        field = find_field(entry, locale, handle, parent)
-        return unless field
-
-        old_entry_ids.each_with_index do |old_id, index|
-          referenced_entry = id_mapping[old_id]
-          next unless referenced_entry
-
-          field.references.create!(entry: referenced_entry, rank: index)
-        end
-      end
-
-      def parse_json(content)
-        JSON.parse(content, symbolize_names: true)
-      rescue JSON::ParserError
-        nil
-      end
-
-      def import_block_definitions(definitions)
-        definitions.each { |attrs| BlockDefinition.import_from_attributes(attrs) }
-      end
-
-      def import_content_types(definitions)
-        definitions.each { |attrs| ContentType.import_from_attributes(attrs) }
-      end
-
-      def resolve_content_type_references(definitions)
-        definitions.each do |attrs|
-          content_type = ContentType.find_by(handle: attrs[:handle])
-          next unless content_type
-
-          if attrs[:title_field_handle].present?
-            field = content_type.field_definitions.find_by(handle: attrs[:title_field_handle])
-            content_type.update!(title_field_definition: field) if field
-          end
-
-          if attrs[:web_page_title_field_handle].present?
-            field = content_type.field_definitions.find_by(handle: attrs[:web_page_title_field_handle])
-            content_type.update!(web_page_title_field_definition: field) if field
-          end
+          Importer.new(tempfile.path, include_schema: include_schema?, include_content: include_content?).import
         end
       end
   end

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

@@ -4,21 +4,15 @@ module Iron
 
     class_methods do
       def import_from_attributes(attrs)
-        block_def = find_or_initialize_by(handle: attrs[:handle])
-        block_def.update!(
-          name: attrs[:name],
-          description: attrs[:description]
-        )
-
-        import_field_definitions(block_def, attrs[:field_definitions] || [])
-
-        block_def
+        find_or_initialize_by(handle: attrs[:handle]).tap do |block_def|
+          block_def.update!(name: attrs[:name], description: attrs[:description])
+        end
       end
 
-      private
+      def populate_field_definitions(attrs)
+        block_def = find_by!(handle: attrs[:handle])
 
-      def import_field_definitions(block_def, field_attrs_list)
-        field_attrs_list.each do |field_attrs|
+        (attrs[:field_definitions] || []).each do |field_attrs|
           FieldDefinition.import_from_attributes(field_attrs, schemable: block_def)
         end
       end

data/app/models/iron/exporter.rb

@@ -0,0 +1,75 @@
+module Iron
+  class Exporter
+    def initialize(path, include_schema: true, include_content: true)
+      @path = path.to_s
+      @include_schema = include_schema
+      @include_content = include_content
+    end
+
+    def export
+      Zip::File.open(path, create: true) do |zip|
+        write_schema(zip) if schema?
+        write_entries(zip) if content?
+      end
+    end
+
+    private
+
+      attr_reader :path
+
+      def schema?  = @include_schema
+      def content? = @include_content
+
+      def write_schema(zip)
+        zip.get_output_stream("schema.json") { |f| f.write(schema_json) }
+      end
+
+      def write_entries(zip)
+        exportable_entries.find_each do |entry|
+          path = "entries/#{entry.content_type.handle}/#{entry.id}.json"
+          zip.get_output_stream(path) { |f| f.write(entry.export_json) }
+
+          entry.export_attachments.each do |attachment|
+            zip.get_output_stream("files/#{attachment[:path]}", compression_method: Zip::Entry::STORED) do |f|
+              attachment[:blob].download { |chunk| f.write(chunk) }
+            end
+          rescue ActiveStorage::FileNotFoundError
+            # Skip missing files
+          end
+        end
+      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)
+      end
+
+      def exportable_entries
+        Entry.includes(:content_type, :creator, fields: [ :locale, :definition ])
+      end
+  end
+end

data/app/models/iron/importer.rb

@@ -0,0 +1,211 @@
+module Iron
+  class Importer
+    def initialize(path, include_schema: true, include_content: true)
+      @path = path.to_s
+      @include_schema = include_schema
+      @include_content = include_content
+    end
+
+    def import
+      Zip::File.open(path) do |zip|
+        files_dir = extract_files(zip)
+
+        import_schema(zip) if schema?
+        import_content(zip, files_dir) if content?
+      ensure
+        FileUtils.rm_rf(files_dir) if files_dir
+      end
+    end
+
+    private
+
+      attr_reader :path
+
+      def schema?  = @include_schema
+      def content? = @include_content
+
+      def extract_files(zip)
+        dir = Dir.mktmpdir("iron-import")
+        zip.glob("files/**/*").each do |entry|
+          next if entry.directory?
+
+          path = File.join(dir, entry.name.sub("files/", ""))
+          FileUtils.mkdir_p(File.dirname(path))
+          entry.extract(path)
+        end
+        dir
+      end
+
+      def import_schema(zip)
+        return unless zip.find_entry("schema.json")
+
+        schema = read_schema(zip)
+
+        ActiveRecord::Base.transaction do
+          import_locales(schema[:locales] || [])
+          import_block_definitions(schema[:block_definitions] || [])
+          populate_block_field_definitions(schema[:block_definitions] || [])
+          import_content_types(schema[:content_types] || [])
+          resolve_content_type_references(schema[:content_types] || [])
+          restore_default_locale(schema[:default_locale])
+        end
+      end
+
+      def import_content(zip, files_dir)
+        ActiveRecord::Base.transaction do
+          id_mapping = {}
+          entries_data = []
+
+          # First pass: create all entries
+          zip.glob("entries/**/*.json").each do |zip_entry|
+            attrs = parse_json(zip_entry.get_input_stream.read)
+            entries_data << attrs
+            entry = Entry.import_from_attributes(attrs, files_dir)
+            id_mapping[attrs[:id]] = entry if entry
+          end
+
+          # Second pass: resolve references
+          resolve_references(entries_data, id_mapping)
+        end
+      end
+
+      def resolve_references(entries_data, id_mapping)
+        entries_data.each do |attrs|
+          entry = id_mapping[attrs[:id]]
+          next unless entry
+
+          (attrs[:fields] || {}).each do |locale_code, field_data|
+            locale = Locale.find_by(code: locale_code.to_s)
+            next unless locale
+
+            resolve_references_in_fields(entry, locale, field_data, id_mapping)
+          end
+        end
+      end
+
+      def resolve_references_in_fields(entry, locale, fields_data, id_mapping, parent: nil)
+        fields_data.each do |handle, value_data|
+          next unless value_data.is_a?(Hash)
+
+          case value_data[:type]
+          when "reference"
+            resolve_reference_field(entry, locale, handle.to_s, value_data[:value], id_mapping, parent: parent)
+          when "reference_list"
+            resolve_reference_list_field(entry, locale, handle.to_s, value_data[:value], id_mapping, parent: parent)
+          when "block"
+            resolve_references_in_block(entry, locale, handle.to_s, value_data, id_mapping, parent: parent)
+          when "block_list"
+            resolve_references_in_block_list(entry, locale, handle.to_s, value_data, id_mapping, parent: parent)
+          end
+        end
+      end
+
+      def resolve_references_in_block(entry, locale, handle, value_data, id_mapping, parent: nil)
+        block_field = find_field(entry, locale, handle, parent)
+        return unless block_field
+
+        resolve_references_in_fields(entry, locale, value_data[:fields] || {}, id_mapping, parent: block_field)
+      end
+
+      def resolve_references_in_block_list(entry, locale, handle, value_data, id_mapping, parent: nil)
+        block_list_field = find_field(entry, locale, handle, parent)
+        return unless block_list_field
+
+        ordered_blocks = block_list_field.blocks.reload.sort_by(&:rank)
+
+        (value_data[:value] || []).each_with_index do |block_data, index|
+          block = ordered_blocks[index]
+          next unless block
+
+          resolve_references_in_fields(entry, locale, block_data[:fields] || {}, id_mapping, parent: block)
+        end
+      end
+
+      def find_field(entry, locale, handle, parent)
+        fields = parent&.fields&.reload || entry.fields.reload
+        definition_scope = parent.is_a?(Fields::Block) ? parent.block_definition.field_definitions : entry.content_type.field_definitions
+        definition = definition_scope.find_by(handle: handle)
+        return unless definition
+
+        fields.find { |f| f.definition_id == definition.id && f.locale_id == locale.id }
+      end
+
+      def resolve_reference_field(entry, locale, handle, old_entry_id, id_mapping, parent: nil)
+        return unless old_entry_id
+
+        referenced_entry = id_mapping[old_entry_id]
+        return unless referenced_entry
+
+        field = find_field(entry, locale, handle, parent)
+        return unless field
+
+        field.update!(referenced_entry: referenced_entry)
+      end
+
+      def resolve_reference_list_field(entry, locale, handle, old_entry_ids, id_mapping, parent: nil)
+        return unless old_entry_ids.is_a?(Array)
+
+        field = find_field(entry, locale, handle, parent)
+        return unless field
+
+        old_entry_ids.each_with_index do |old_id, index|
+          referenced_entry = id_mapping[old_id]
+          next unless referenced_entry
+
+          field.references.create!(entry: referenced_entry, rank: index)
+        end
+      end
+
+      def read_schema(zip)
+        parse_json(zip.read("schema.json"))
+      end
+
+      def parse_json(content)
+        JSON.parse(content, symbolize_names: true)
+      end
+
+      def import_locales(locales)
+        locales.each do |attrs|
+          Locale.find_or_create_by!(code: attrs[:code]) do |locale|
+            locale.name = attrs[:name]
+          end
+        end
+      end
+
+      def restore_default_locale(locale_code)
+        return unless locale_code
+
+        locale = Locale.find_by(code: locale_code)
+        Current.account.update!(default_locale: locale) if locale
+      end
+
+      def import_block_definitions(definitions)
+        definitions.each { |attrs| BlockDefinition.import_from_attributes(attrs) }
+      end
+
+      def populate_block_field_definitions(definitions)
+        definitions.each { |attrs| BlockDefinition.populate_field_definitions(attrs) }
+      end
+
+      def import_content_types(definitions)
+        definitions.each { |attrs| ContentType.import_from_attributes(attrs) }
+      end
+
+      def resolve_content_type_references(definitions)
+        definitions.each do |attrs|
+          content_type = ContentType.find_by(handle: attrs[:handle])
+          next unless content_type
+
+          if attrs[:title_field_handle].present?
+            field = content_type.field_definitions.find_by(handle: attrs[:title_field_handle])
+            content_type.update!(title_field_definition: field) if field
+          end
+
+          if attrs[:web_page_title_field_handle].present?
+            field = content_type.field_definitions.find_by(handle: attrs[:web_page_title_field_handle])
+            content_type.update!(web_page_title_field_definition: field) if field
+          end
+        end
+      end
+  end
+end

data/app/models/iron/seed.rb

@@ -0,0 +1,77 @@
+module Iron
+  class Seed
+    DEFAULT_PATH = "db/seeds/iron.zip"
+
+    def self.dump(path = nil) = new(path).dump
+    def self.load(path = nil) = new(path).load
+
+    def dump
+      FileUtils.mkdir_p(path.dirname)
+      Exporter.new(path).export
+    end
+
+    def load
+      return unless path.exist?
+      return if already_seeded?
+
+      user, account = bootstrap
+      Current.set(user: user, account: account) do
+        Importer.new(path).import
+      end
+    end
+
+    private_class_method :new
+
+    private
+
+      attr_reader :path
+
+      def initialize(path)
+        @path = Pathname.new(path || Rails.root.join(DEFAULT_PATH))
+      end
+
+      def already_seeded?
+        ContentType.any?
+      end
+
+      def bootstrap
+        locale = Locale.first || Locale.create!(**default_locale_attributes)
+        account = Account.first || Account.create!(name: "Iron", default_locale: locale)
+        user = User.first || User.create!(
+          email_address: seed_email,
+          password: seed_password,
+          role: :administrator
+        )
+        [ user, account ]
+      end
+
+      def seed_email
+        ENV["IRON_SEED_EMAIL"] || default_credential("admin@example.com")
+      end
+
+      def seed_password
+        ENV["IRON_SEED_PASSWORD"] || default_credential("password")
+      end
+
+      def default_credential(value)
+        raise "IRON_SEED_EMAIL and IRON_SEED_PASSWORD must be set in #{Rails.env}" unless Rails.env.local?
+        value
+      end
+
+      def default_locale_attributes
+        schema = read_seed_schema
+        locale_code = schema&.dig(:default_locale)
+        locale_attrs = schema&.dig(:locales)&.find { |l| l[:code] == locale_code }
+        locale_attrs&.slice(:code, :name) || { code: "en", name: "English" }
+      end
+
+      def read_seed_schema
+        return unless path.exist?
+
+        Zip::File.open(path.to_s) do |zip|
+          entry = zip.find_entry("schema.json")
+          JSON.parse(entry.get_input_stream.read, symbolize_names: true) if entry
+        end
+      end
+  end
+end

data/app/models/iron/user/deactivatable.rb

@@ -0,0 +1,23 @@
+module Iron::User::Deactivatable
+  extend ActiveSupport::Concern
+
+  included do
+    scope :active, -> { where(active: true) }
+  end
+
+  def deactivate
+    if current?
+      errors.add(:base, :cannot_deactivate_self)
+      return false
+    end
+
+    transaction do
+      sessions.destroy_all
+      update!(active: false)
+    end
+  end
+
+  def reactivate
+    update!(active: true)
+  end
+end

data/app/models/iron/user.rb

@@ -1,5 +1,6 @@
 module Iron
   class User < ApplicationRecord
+    include Deactivatable
     include Role
     include Transferable
 
@@ -7,8 +8,6 @@ module Iron
 
     validates :language, inclusion: { in: ADMIN_LANGUAGES }
 
-    before_destroy :ensure_not_current_user
-
     has_secure_password
     has_many :sessions, dependent: :destroy
     has_many :exports, class_name: "Iron::Account::Export", dependent: :destroy
@@ -33,12 +32,5 @@ module Iron
       def email_local_part
         email_address.split("@").first
       end
-
-      def ensure_not_current_user
-        if Current.user == self
-          errors.add(:base, :cannot_delete_self)
-          throw :abort
-        end
-      end
   end
 end

data/app/views/iron/users/index.html.erb

@@ -25,4 +25,29 @@
       <%= render @users %>
     </div>
   </section>
+
+  <% if @deactivated_users.any? %>
+    <section>
+      <h2 class="text-sm font-medium text-stone-500 dark:text-stone-400 mb-3"><%= t(".deactivated") %></h2>
+      <div class="card card-list">
+        <% @deactivated_users.each do |user| %>
+          <div class="card-item flex items-center justify-between gap-4">
+            <div class="flex items-center gap-3 min-w-0 flex-1">
+              <%= avatar user, class: "size-9 bg-stone-100 text-stone-500 text-[14px] dark:bg-stone-700 dark:text-stone-300 opacity-50" %>
+              <div class="min-w-0">
+                <span class="block text-sm font-medium text-stone-400 dark:text-stone-500 truncate"><%= user.name %></span>
+                <p class="text-xs text-stone-400 dark:text-stone-500 truncate"><%= user.email_address %></p>
+              </div>
+            </div>
+
+            <div class="flex items-center gap-2 shrink-0">
+              <%= button_to user_reactivation_path(user), method: :patch, class: "button-ghost button-sm" do %>
+                <%= t(".reactivate") %>
+              <% end %>
+            </div>
+          </div>
+        <% end %>
+      </div>
+    </section>
+  <% end %>
 </div>

data/config/locales/en.yml

@@ -30,7 +30,7 @@ en:
         iron/user:
           attributes:
             base:
-              cannot_delete_self: "You cannot delete your own account while logged in"
+              cannot_deactivate_self: "You cannot delete your own account while logged in"
             role:
               cannot_change_own_role: "cannot be changed for your own account"
   iron:
@@ -455,8 +455,10 @@ en:
         count:
           one: "1 member"
           other: "%{count} members"
+        deactivated: "Deactivated"
         heading: "Users"
         invite: "Invite"
+        reactivate: "Reactivate"
         team: "Team"
         title: "Users"
       invite:
@@ -475,6 +477,7 @@ en:
         title: "Join %{account}"
       notifications:
         password_changed: "Password changed."
+        reactivated: "User was successfully reactivated."
         removed: "User was successfully removed."
       roles:
         administrator: "Administrator"

data/config/locales/it.yml

@@ -69,7 +69,7 @@ it:
         iron/user:
           attributes:
             base:
-              cannot_delete_self: "Non puoi eliminare il tuo account mentre sei autenticato"
+              cannot_deactivate_self: "Non puoi eliminare il tuo account mentre sei autenticato"
             role:
               cannot_change_own_role: "non può essere cambiato per il tuo account"
   iron:
@@ -494,8 +494,10 @@ it:
         count:
           one: "1 membro"
           other: "%{count} membri"
+        deactivated: "Disattivati"
         heading: "Utenti"
         invite: "Invita"
+        reactivate: "Riattiva"
         team: "Team"
         title: "Utenti"
       invite:
@@ -514,6 +516,7 @@ it:
         title: "Unisciti a %{account}"
       notifications:
         password_changed: "Password cambiata."
+        reactivated: "Utente riattivato con successo."
         removed: "Utente rimosso con successo."
       roles:
         administrator: "Amministratore"

data/config/routes.rb

@@ -32,6 +32,7 @@ Iron::Engine.routes.draw do
       resource :email, only: :update
       resource :password, only: :update
       resource :language, only: :update
+      resource :reactivation, only: :update
       resource :role, only: :update
     end
   end

data/db/migrate/20260209215027_add_active_to_iron_users.rb

@@ -0,0 +1,5 @@
+class AddActiveToIronUsers < ActiveRecord::Migration[8.1]
+  def change
+    add_column :iron_users, :active, :boolean, default: true, null: false
+  end
+end

data/lib/iron/version.rb

@@ -1,3 +1,3 @@
 module Iron
-  VERSION = "0.12.0"
+  VERSION = "0.13.0"
 end

data/lib/tasks/iron_tasks.rake

@@ -1,24 +1,15 @@
 namespace :iron do
-  namespace :fixtures do
-    desc "Generate test fixtures from current database"
-    task generate: :environment do
-      fixture_dir = Rails.root.join("test/fixtures/iron")
-      FileUtils.mkdir_p(fixture_dir)
-
-      schema_path = fixture_dir.join("schema.tar.gz")
-      content_path = fixture_dir.join("content.tar.gz")
-
-      puts "Exporting Iron schema to #{schema_path}..."
-      schema_tar = Iron::SchemaExporter.export
-      File.binwrite(schema_path, schema_tar)
-
-      puts "Exporting Iron content to #{content_path}..."
-      content_archive = Iron::ContentExport.export
-      content_archive.to_file(content_path)
+  namespace :seed do
+    desc "Dump CMS schema and content to db/seeds/iron.zip"
+    task dump: :environment do
+      path = ENV["SEED_PATH"]
+      Iron::Seed.dump(path)
+      puts "Iron CMS seed exported to #{path || Rails.root.join(Iron::Seed::DEFAULT_PATH)}"
+    end
 
-      puts "Test fixtures generated successfully!"
-      puts "  - Schema: #{schema_path}"
-      puts "  - Content: #{content_path}"
+    desc "Load CMS schema and content from db/seeds/iron.zip"
+    task load: :environment do
+      Iron::Seed.load(ENV["SEED_PATH"])
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iron-cms
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Massimo De Marchi
@@ -286,6 +286,7 @@ files:
 - app/controllers/iron/users/emails_controller.rb
 - app/controllers/iron/users/languages_controller.rb
 - app/controllers/iron/users/passwords_controller.rb
+- app/controllers/iron/users/reactivations_controller.rb
 - app/controllers/iron/users/roles_controller.rb
 - app/controllers/iron/users_controller.rb
 - app/helpers/iron/application_helper.rb
@@ -351,6 +352,7 @@ files:
 - app/models/iron/entry/schemable.rb
 - app/models/iron/entry/titlable.rb
 - app/models/iron/entry/web_publishable.rb
+- app/models/iron/exporter.rb
 - app/models/iron/field.rb
 - app/models/iron/field/belongs_to_entry.rb
 - app/models/iron/field_definition.rb
@@ -380,11 +382,14 @@ files:
 - app/models/iron/fields/text_field.rb
 - app/models/iron/first_run.rb
 - app/models/iron/icon_catalog.rb
+- app/models/iron/importer.rb
 - app/models/iron/locale.rb
 - app/models/iron/qr_code_link.rb
 - app/models/iron/reference.rb
+- app/models/iron/seed.rb
 - app/models/iron/session.rb
 - app/models/iron/user.rb
+- app/models/iron/user/deactivatable.rb
 - app/models/iron/user/role.rb
 - app/models/iron/user/transferable.rb
 - app/views/active_storage/blobs/_blob.html.erb
@@ -517,6 +522,7 @@ files:
 - db/migrate/20251209103109_create_iron_account_exports.rb
 - db/migrate/20251209103110_create_iron_account_imports.rb
 - db/migrate/20260207103057_add_language_to_iron_users.rb
+- db/migrate/20260209215027_add_active_to_iron_users.rb
 - lib/generators/iron/pages/pages_generator.rb
 - lib/generators/iron/pages/templates/pages_controller.rb
 - lib/generators/iron/pages/templates/show.html.erb