mxrb 0.1.2 → 0.1.4

data/lib/mxrb/model/module.rb

@@ -7,6 +7,40 @@ module Mxrb
     # $Type: Projects$Module
     # ContainmentName: "Modules"
     class Module < Unit
+      INFRASTRUCTURE_DOCUMENT_ROUTES = {
+        'ExportMappings$ExportMapping' => 'mappings/exports',
+        'ImportMappings$ImportMapping' => 'mappings/imports',
+        'JsonStructures$JsonStructure' => 'mappings/json_structures',
+        'MessageDefinitions$MessageDefinitionCollection' => 'mappings/message_definitions',
+        'MessageDefinitions$MessageDefinition2' => 'mappings/message_definitions',
+        'XmlSchemas$XmlSchema' => 'mappings/xml_schemas',
+        'Rest$PublishedRestService' => 'endpoints',
+        'WebServices$PublishedService' => 'endpoints',
+        'WebServices$PublishedWebService' => 'endpoints',
+        'ODataPublish$PublishedODataService' => 'endpoints',
+        'ODataPublish$PublishedODataService2' => 'endpoints',
+        'Rest$ConsumedRestService' => 'integrations',
+        'Rest$ConsumedODataService' => 'integrations',
+        'AppServices$ConsumedAppService' => 'integrations',
+        'ODataImport$ConsumedODataService' => 'integrations'
+      }.freeze
+      MAPPING_DOCUMENT_TYPES = INFRASTRUCTURE_DOCUMENT_ROUTES.keys.grep(
+        /Mappings|JsonStructures|MessageDefinitions|XmlSchemas/
+      ).freeze
+      APPLICATION_DOCUMENT_ROUTES = {
+        'DataSets$DataSet' => 'queries/datasets',
+        'ScheduledEvents$ScheduledEvent' => 'jobs/scheduled_events'
+      }.freeze
+      DOMAIN_DOCUMENT_ROUTES = {
+        'DomainModels$ViewEntitySourceDocument' => 'oql_views',
+        'Enumerations$Enumeration' => 'enumerations',
+        'Constants$Constant' => 'constants'
+      }.freeze
+      EDITABLE_DOCUMENT_TYPES = (
+        INFRASTRUCTURE_DOCUMENT_ROUTES.keys + APPLICATION_DOCUMENT_ROUTES.keys +
+        DOMAIN_DOCUMENT_ROUTES.keys
+      ).freeze
+
       attr_reader :name, :sort_index, :from_app_store,
                   :app_store_guid, :app_store_version, :export_level
 
@@ -84,6 +118,28 @@ module Mxrb
                               .map { unit_to_doc(_1) }
       end
 
+      def mapping_documents
+        infrastructure_documents.select { MAPPING_DOCUMENT_TYPES.include?(_1[:type]) }
+      end
+
+      def infrastructure_documents
+        @infrastructure_documents ||= routed_documents(INFRASTRUCTURE_DOCUMENT_ROUTES)
+      end
+
+      def application_documents
+        @application_documents ||= routed_documents(APPLICATION_DOCUMENT_ROUTES)
+      end
+
+      def domain_documents
+        @domain_documents ||= routed_documents(DOMAIN_DOCUMENT_ROUTES)
+      end
+
+      def oql_view_documents
+        @oql_view_documents ||= domain_documents.select do |document|
+          document[:type] == 'DomainModels$ViewEntitySourceDocument'
+        end
+      end
+
       def module_roles
         @module_roles ||= begin
           raw = @mpr.children_of(@id).find { _1["ContainmentName"] == "ModuleSecurity" }
@@ -109,6 +165,21 @@ module Mxrb
         @mpr.parse_contents(unit_hash[:raw])
       end
 
+      def routed_documents(routes)
+        document_units.filter_map do |unit|
+          route = routes[unit[:type]]
+          next unless route
+
+          raw = unit.fetch(:raw)
+          doc = @mpr.parse_contents(raw)
+          {
+            id: raw.fetch("UnitID"), container_id: raw.fetch("ContainerID"),
+            containment: raw.fetch("ContainmentName"), type: unit.fetch(:type),
+            name: doc["Name"] || doc["name"] || raw.fetch("UnitID"), doc:, route:
+          }
+        end
+      end
+
       # Documents live in ContainmentName = "Documents" recursively under this module.
       # We do a simple two-pass: direct Documents children + Documents inside Folders.
       def document_units

data/lib/mxrb/model/page.rb

@@ -10,7 +10,8 @@ module Mxrb
       attr_reader :name, :documentation, :url, :layout_id, :title,
                   :popup_width, :popup_height, :popup_resizable, :excluded,
                   :allowed_module_roles, :parameters, :export_level,
-                  :widgets, :data_source, :raw_document
+                  :widgets, :data_source, :appearance_class, :appearance_style,
+                  :raw_document
 
       def decode(doc)
         @raw_document        = doc
@@ -25,6 +26,8 @@ module Mxrb
         @popup_resizable     = doc["PopupResizable"] == true
         @excluded            = doc["Excluded"] == true
         @export_level        = doc["ExportLevel"] || "Hidden"
+        @appearance_class    = doc.dig("Appearance", "Class").to_s
+        @appearance_style    = doc.dig("Appearance", "Style").to_s
         @allowed_module_roles = parse_array(doc["AllowedModuleRoles"] || doc["AllowedRoles"] || doc["allowedModuleRoles"])
         @parameters          = parse_array(doc["Parameters"] || doc["parameters"])
         @widgets             = []
@@ -112,7 +115,8 @@ module Mxrb
             children = []
             parse_widgets(parse_array(widget["Widgets"]), children)
             target << { type: :container, name: widget["Name"] || "container",
-                        options: container_options(widget), children: children, events: [] }
+                        options: container_options(widget), children: children,
+                        events: container_events(widget) }
             next
           end
           if layout_container?(widget)
@@ -171,17 +175,42 @@ module Mxrb
       end
 
       def widget_options(widget, widget_type)
-        options = {
+        options = appearance_options(widget).merge(
           attribute: attribute_path(widget),
           caption: widget_caption(widget, widget_type)
-        }.compact
+        ).compact
+        parameters = template_parameters(widget)
+        options[:parameters] = parameters unless parameters.empty?
         options[:lines] = widget["NumberOfLines"] if widget_type == :text_area && widget["NumberOfLines"]
         options
       end
 
       def container_options(widget)
+        appearance_options(widget)
+      end
+
+      def appearance_options(widget)
         class_name = widget.dig("Appearance", "Class") || widget["Class"]
-        class_name.to_s.empty? ? {} : { class: class_name }
+        style = widget.dig("Appearance", "Style") || widget["Style"]
+        dynamic = widget.dig("Appearance", "DynamicClasses")
+        visibility = widget.dig("ConditionalVisibilitySettings", "Expression")
+        { class: class_name.to_s, style: style.to_s,
+          dynamic_class: dynamic.to_s, visible: visibility.to_s }.reject { |_key, value| value.empty? }
+      end
+
+      def container_events(widget)
+        action = parse_action(widget["OnClickAction"] || widget["Action"])
+        action ? [action.merge(event: :on_click)] : []
+      end
+
+      def template_parameters(widget)
+        template = widget["Content"] || widget["CaptionTemplate"] || widget["LabelTemplate"]
+        parse_array(template.is_a?(Hash) ? template["Parameters"] : nil).filter_map do |parameter|
+          expression = parameter["Expression"].to_s
+          attribute = parameter.dig("AttributeRef", "Attribute").to_s.split('.').last.to_s
+          expression = "$currentObject/#{attribute}" if expression.empty? && !attribute.empty?
+          expression unless expression.empty?
+        end
       end
 
       def attribute_path(widget)
@@ -210,27 +239,58 @@ module Mxrb
         options = { entity: grid_entity(widget), columns: columns }.compact
         options[:search_bar] = parse_search_bar(widget["SearchBar"]) if widget["SearchBar"].is_a?(Hash)
         options[:toolbar]    = parse_toolbar(widget["ToolBar"])       if widget["ToolBar"].is_a?(Hash)
-        { type: :data_grid, name: widget["Name"], options: options, events: [] }
+        { type: :data_grid, name: widget["Name"], options: options, events: grid_events(widget) }
       end
 
       def pluggable_widget(widget)
         case widget.dig("Type", "WidgetId")
         when "com.mendix.widget.web.datagrid.Datagrid" then data_grid2_widget(widget)
         when "com.mendix.widget.web.combobox.Combobox"  then combo_box_widget(widget)
+        when "com.mendix.widget.web.gallery.Gallery"    then gallery_widget(widget)
         else native_widget(widget)
         end
       end
 
+      def gallery_widget(widget)
+        properties = custom_property_map(widget["Object"], widget.dig("Type", "ObjectType"))
+        source = properties.dig("datasource", "DataSource") || {}
+        children = []
+        parse_widgets(parse_array(properties.dig("content", "Widgets")), children)
+        sort = parse_array(source.dig("SortBar", "SortItems")).map do |item|
+          {
+            attribute: item.dig("AttributeRef", "Attribute"),
+            direction: item["SortDirection"].to_s
+          }.compact
+        end
+        xpath = source["XPathConstraint"].to_s
+        options = appearance_options(widget).merge(
+          entity: source.dig("EntityRef", "Entity"), xpath: xpath,
+          association: xpath[/\[([\w.]+)\s*=\s*\$\w+\]/, 1],
+          context_variable: xpath[/\$([A-Za-z_]\w*)/, 1], sort: sort
+        ).compact
+        {
+          type: :gallery, name: widget["Name"], options: options,
+          children: children, events: []
+        }
+      end
+
       def native_widget(widget)
         deep = widget.reject { |key, _| %w[$ID $Type Name].include?(key.to_s) }
+        widget_id = widget.dig("Type", "WidgetId").to_s
+        platform = widget.dig("Type", "SupportedPlatform").to_s
+        options = { native_type: widget["$Type"], deep_structure: deep }
+        options[:widget_id] = widget_id unless widget_id.empty?
+        options[:platform] = platform unless platform.empty?
         {
           type: :native_widget, name: widget["Name"] || "widget",
-          options: { native_type: widget["$Type"], deep_structure: deep }, events: []
+          options:, events: []
         }
       end
 
       def data_grid2_widget(widget)
         properties = custom_property_map(widget["Object"], widget.dig("Type", "ObjectType"))
+        return data_grid_widget(widget) if properties.empty? && widget["DataSource"]
+
         entity = properties.dig("datasource", "DataSource", "EntityRef", "Entity")
         column_type = custom_property_type(widget.dig("Type", "ObjectType"), "columns")
                       &.dig("ValueType", "ObjectType")
@@ -244,12 +304,35 @@ module Mxrb
         end
         {
           type: :data_grid, name: widget["Name"],
-          options: { entity: entity, columns: columns }.compact, events: []
+          options: { entity: entity, columns: columns }.compact, events: grid_events(widget)
         }
       end
 
+      def grid_events(widget)
+        {
+          "OnChangeAction" => :on_change,
+          "OnClickAction" => :on_click,
+          "Action" => :on_click
+        }.filter_map do |property, event|
+          action = parse_action(widget[property])
+          action&.merge(event: event)
+        end
+      end
+
       def combo_box_widget(widget)
         properties = custom_property_map(widget["Object"], widget.dig("Type", "ObjectType"))
+        if properties.empty? && widget["AttributePath"]
+          reference = widget["SelectorType"] == "Reference"
+          options = {
+            attribute: widget["AttributePath"], caption: extract_text(widget["LabelText"]),
+            display_attribute: widget["DisplayAttribute"]
+          }.compact
+          return {
+            type: reference ? :reference_selector : :drop_down,
+            name: widget["Name"], options: options, events: grid_events(widget)
+          }
+        end
+
         association = parse_array(properties.dig("attributeAssociation", "EntityRef", "Steps"))
                       .first&.fetch("Association", nil)
         reference = properties.dig("optionsSourceType", "PrimitiveValue") == "association"
@@ -267,7 +350,7 @@ module Mxrb
           )
         end
         { type: reference ? :reference_selector : :drop_down,
-          name: widget["Name"], options: options.compact, events: [] }
+          name: widget["Name"], options: options.compact, events: grid_events(widget) }
       end
 
       def custom_property_map(object, object_type)
@@ -376,21 +459,49 @@ module Mxrb
       def parse_source(source)
         return nil unless source.is_a?(Hash)
         result = if %w[Pages$NanoflowSource Forms$NanoflowSource].include?(source["$Type"])
-          { kind: :nanoflow, name: local_name(source["Nanoflow"] || source.dig("NanoflowSettings", "Nanoflow")) }
+          { kind: :nanoflow, name: source_name(source["Nanoflow"] || source.dig("NanoflowSettings", "Nanoflow")) }
         else
-          { kind: :microflow, name: local_name(source["Microflow"] || source.dig("MicroflowSettings", "Microflow")) }
+          { kind: :microflow, name: source_name(source["Microflow"] || source.dig("MicroflowSettings", "Microflow")) }
         end
         result[:name].to_s.empty? ? nil : result
       end
 
+      # Page data sources are architectural references. Unlike widget-local
+      # action handlers, their module qualification must survive export so a
+      # native Core.Flow reference cannot silently become Portal.Flow.
+      def source_name(name)
+        name.to_s
+      end
+
       def parse_action(action)
         return nil unless action.is_a?(Hash)
         if %w[Pages$CallNanoflowClientAction Forms$CallNanoflowClientAction].include?(action["$Type"])
-          handler = local_name(action["Nanoflow"] || action.dig("NanoflowSettings", "Nanoflow"))
-          handler.to_s.empty? ? nil : { kind: :nanoflow, handler: handler }
+          settings = action["NanoflowSettings"] || action
+          handler = local_name(action["Nanoflow"] || settings["Nanoflow"])
+          return nil if handler.to_s.empty?
+
+          arguments = parse_array(settings["ParameterMappings"]).to_h do |mapping|
+            [local_name(mapping["Parameter"]), mapping["Expression"].to_s]
+          end
+          { kind: :nanoflow, handler: handler, arguments: arguments }
         elsif %w[Pages$MicroflowClientAction Forms$MicroflowAction Forms$MicroflowClientAction].include?(action["$Type"])
-          handler = local_name(action["Microflow"] || action.dig("MicroflowSettings", "Microflow"))
-          handler.to_s.empty? ? nil : { kind: :microflow, handler: handler }
+          settings = action["MicroflowSettings"] || action
+          handler = local_name(action["Microflow"] || settings["Microflow"])
+          return nil if handler.to_s.empty?
+
+          arguments = parse_array(settings["ParameterMappings"]).to_h do |mapping|
+            [local_name(mapping["Parameter"]), mapping["Expression"].to_s]
+          end
+          { kind: :microflow, handler: handler, arguments: arguments }
+        elsif %w[Pages$FormAction Forms$FormAction].include?(action["$Type"])
+          settings = action["FormSettings"] || action
+          handler = settings["Form"].to_s
+          return nil if handler.empty?
+
+          arguments = parse_array(settings["ParameterMappings"]).to_h do |mapping|
+            [local_name(mapping["Parameter"]), mapping["Expression"].to_s]
+          end
+          { kind: :page, handler: handler, arguments: arguments }
         elsif %w[Pages$SaveChangesClientAction Forms$SaveChangesClientAction].include?(action["$Type"])
           { kind: :action, handler: "save_changes" }
         elsif %w[Pages$CancelChangesClientAction Forms$CancelChangesClientAction].include?(action["$Type"])

data/lib/mxrb/model/project.rb

@@ -63,6 +63,9 @@ module Mxrb
         analyzer = Oql::Analyzer.new(dialect:)
         oql_queries.map { analyzer.analyze(_1) }.freeze
       end
+      def sql_to_oql(source, dialect: :postgresql)
+        Oql::ReverseTranslator.new(dialect:, project: self).translate(source)
+      end
 
       # ── Semantic analysis ───────────────────────────────────────────────
 

data/lib/mxrb/modeler/catalog.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Modeler
+    # Read-only, JSON-safe projection used by the React project modeler.
+    # rubocop:disable Metrics
+    class Catalog
+      SETTINGS_PATTERN = /(?:Settings|Configuration)\$|(?:Settings|Configuration)\z/
+
+      def initialize(path)
+        @path = File.expand_path(path)
+      end
+
+      def to_h
+        project = Model::Project.open(@path)
+        documents = project_documents(project)
+        modules = project.modules.map { module_payload(_1) }
+        {
+          project: project_payload(project),
+          summary: summary(modules),
+          modules:,
+          navigation: project.navigation.to_h,
+          security: security_payload(documents),
+          settings: settings_payload(documents)
+        }
+      ensure
+        project&.close
+      end
+
+      private
+
+      def project_payload(project)
+        {
+          name: project.name,
+          mendix_version: project.mendix_version,
+          format_version: project.format_version
+        }
+      end
+
+      def summary(modules)
+        keys = %i[entities pages microflows nanoflows integrations configurations]
+        { modules: modules.size }.merge(
+          keys.to_h { |key| [key, modules.sum { Array(_1[key]).size }] }
+        )
+      end
+
+      def module_payload(mod)
+        documents = catalog_documents(mod)
+        integration_groups = %w[endpoints integrations mappings]
+        {
+          id: mod.id,
+          name: mod.name,
+          marketplace: mod.from_app_store == true,
+          marketplace_guid: blank_to_nil(mod.app_store_guid),
+          marketplace_version: blank_to_nil(mod.app_store_version),
+          entities: mod.entities.map { entity_payload(_1, mod.name) },
+          pages: mod.pages.map { page_payload(_1, mod.name) },
+          microflows: mod.microflows.map { flow_payload(_1, mod.name, 'microflow') },
+          nanoflows: mod.nanoflows.map { flow_payload(_1, mod.name, 'nanoflow') },
+          module_roles: mod.module_roles,
+          integrations: documents.select { integration_groups.include?(_1[:group]) },
+          configurations: documents.reject { integration_groups.include?(_1[:group]) }
+        }
+      end
+
+      def entity_payload(entity, module_name)
+        {
+          id: entity.id,
+          name: entity.name,
+          qualified_name: entity.qualified_name || "#{module_name}.#{entity.name}",
+          persistent: entity.persistable == true,
+          attributes: entity.attributes.map do |attribute|
+            { name: attribute.name, type: attribute.type.to_s, required: attribute.required == true }
+          end
+        }
+      end
+
+      def page_payload(page, module_name)
+        widgets = flatten_widgets(page.widgets)
+        {
+          id: page.id,
+          name: page.name,
+          qualified_name: "#{module_name}.#{page.name}",
+          title: page.title,
+          url: page.url,
+          layout_id: page.layout_id,
+          excluded: page.excluded == true,
+          allowed_module_roles: page.allowed_module_roles.map(&:to_s),
+          widget_count: widgets.size,
+          widget_types: widgets.filter_map { _1[:type]&.to_s }.tally
+        }
+      end
+
+      def flow_payload(flow, module_name, kind)
+        {
+          id: flow.id,
+          name: flow.name,
+          qualified_name: "#{module_name}.#{flow.name}",
+          kind:,
+          documentation: flow.documentation.to_s,
+          allowed_module_roles: flow.allowed_module_roles.map(&:to_s),
+          parameter_count: flow.parameters.size,
+          object_count: flow.objects.size,
+          flow_count: flow.flows.size
+        }
+      end
+
+      def flatten_widgets(widgets)
+        Array(widgets).flat_map do |widget|
+          next [] unless widget.is_a?(Hash)
+
+          [widget, *flatten_widgets(widget[:children] || widget['children'])]
+        end
+      end
+
+      def catalog_documents(mod)
+        documents = mod.infrastructure_documents + mod.application_documents + mod.domain_documents
+        documents.map do |document|
+          {
+            id: document[:id],
+            name: document[:name].to_s,
+            type: document[:type],
+            group: document[:route].to_s.split('/').first
+          }
+        end
+      end
+
+      def project_documents(project)
+        project.all_units.filter_map do |unit|
+          document = project.parse_bson(unit)
+          type = document['$Type'].to_s
+          next if type.empty?
+
+          { id: unit['UnitID'], type:, document: }
+        end
+      end
+
+      def security_payload(documents)
+        source = documents.find { _1[:type] == 'Security$ProjectSecurity' }&.fetch(:document)
+        return { configured: false, level: nil, user_roles: [] } unless source
+
+        roles = array(source['UserRoles']).map do |role|
+          {
+            name: role['Name'].to_s,
+            description: role['Description'].to_s,
+            module_roles: array(role['ModuleRoles']).map(&:to_s)
+          }
+        end
+        { configured: true, level: source['SecurityLevel'], user_roles: roles }
+      end
+
+      def settings_payload(documents)
+        documents.filter { _1[:type].match?(SETTINGS_PATTERN) }.map do |entry|
+          document = entry[:document]
+          {
+            id: entry[:id],
+            type: entry[:type],
+            name: document['Name'].to_s,
+            values: scalar_values(document)
+          }
+        end
+      end
+
+      def scalar_values(document)
+        document.each_with_object({}) do |(key, value), result|
+          next if key.start_with?('$') || value.is_a?(Hash) || value.is_a?(Array)
+
+          result[key] = value
+        end
+      end
+
+      def array(value) = IO::BsonCodec.parse_array(value)[:items]
+
+      def blank_to_nil(value) = value.to_s.empty? ? nil : value
+    end
+    # rubocop:enable Metrics
+  end
+end

data/lib/mxrb/official_marketplace/module_package_importer.rb

@@ -122,6 +122,7 @@ module Mxrb
       def install(staged_files, protected_files = [])
         staged_files.each do |relative, source|
           install_file(relative, source) unless protected_files.include?(relative)
+          yield(relative) if block_given?
         end
       end
 
@@ -179,9 +180,12 @@ module Mxrb
       end
 
       def import!
-        validate_inputs!
-        Dir.mktmpdir('mxrb-module-import-') do |temporary|
-          Zip::File.open(@package_path) { import_archive(_1, temporary) }
+        Progress.with("Importing #{File.basename(@package_path)}") do |progress|
+          validate_inputs!
+          progress.update(detail: 'reading package')
+          Dir.mktmpdir('mxrb-module-import-') do |temporary|
+            Zip::File.open(@package_path) { import_archive(_1, temporary, progress) }
+          end
         end
       rescue Zip::Error, REXML::ParseException => e
         raise MarketplaceError, "invalid Mendix module package: #{e.message}"
@@ -189,12 +193,12 @@ module Mxrb
 
       private
 
-      def import_archive(archive, temporary)
+      def import_archive(archive, temporary, progress)
         reader = ModulePackageReader.new(archive)
         descriptor = reader.descriptor
         source_path = reader.extract_project(descriptor, temporary)
         staged_files = reader.stage_files(descriptor.files, temporary)
-        import_project(source_path, descriptor, staged_files, temporary)
+        import_project(source_path, descriptor, staged_files, temporary, progress)
       end
 
       def validate_inputs!
@@ -203,12 +207,13 @@ module Mxrb
         raise MarketplaceError, "target root not found: #{@target_root}" unless File.directory?(@target_root)
       end
 
-      def import_project(source_path, descriptor, staged_files, temporary) # rubocop:disable Metrics/MethodLength
+      def import_project(source_path, descriptor, staged_files, temporary, progress) # rubocop:disable Metrics/MethodLength
         source = IO::MprFile.open(source_path, readonly: true)
         target = IO::MprFile.open(@mpr_path)
         assets = ModulePackageAssets.new(@target_root, temporary)
         imported_ids = []
-        import_transaction(source, target, descriptor, staged_files, assets, imported_ids)
+        import_transaction(source, target, descriptor, staged_files, assets, imported_ids, progress)
+        progress.advance(detail: 'import transaction')
         import_result(source, target, descriptor, staged_files, imported_ids)
       rescue StandardError
         assets&.rollback
@@ -220,24 +225,30 @@ module Mxrb
       end
 
       # rubocop:disable Metrics/ParameterLists
-      def import_transaction(source, target, descriptor, staged_files, assets, imported_ids)
+      def import_transaction(source, target, descriptor, staged_files, assets, imported_ids, progress) # rubocop:disable Metrics/MethodLength
         validate_versions!(source, target, descriptor)
         module_unit, units = package_units(source, descriptor.name)
         validate_target!(target, descriptor.name, units)
+        progress.update(
+          current: 2, total: units.size + staged_files.size + 3,
+          detail: "#{units.size} model units"
+        )
         target.transaction do
-          imported_ids.concat(insert_units(source, target, module_unit, units))
-          assets.install(staged_files, @protected_files)
+          imported_ids.concat(insert_units(source, target, module_unit, units, progress))
+          assets.install(staged_files, @protected_files) do |relative|
+            progress.advance(detail: "asset #{relative}")
+          end
         end
       end
       # rubocop:enable Metrics/ParameterLists
 
-      def insert_units(source, target, module_unit, units)
+      def insert_units(source, target, module_unit, units, progress)
         units.map do |unit|
           container = unit == module_unit ? target.root_unit.fetch('UnitID') : unit.fetch('ContainerID')
           target.insert_unit(
             container_uuid: container, containment_name: unit.fetch('ContainmentName'),
             contents_doc: source.parse_contents(unit)
-          )
+          ).tap { progress.advance(detail: "unit #{unit.fetch('UnitID')}") }
         end
       end
 

data/lib/mxrb/official_marketplace/widget_package_installer.rb

@@ -200,17 +200,21 @@ module Mxrb
       end
 
       def install(archive, package)
-        validate_target!
-        inventory = WidgetPackageInventory.read(archive)
-        validate_identity!(inventory, package)
-        digest = Digest::SHA256.file(archive).hexdigest
-        destination = safe_path(File.join('widgets', inventory.project_filename))
-        cache = safe_path(cache_relative(inventory, package))
-        lock_path = safe_path(File.join('.mxrb', 'marketplace.lock.json'))
-        current = validate_boundaries!(package, destination, cache, lock_path)
-        install_transaction(
-          archive, package, inventory, digest, destination, cache, lock_path, current
-        )
+        Progress.with("Installing widget #{package.name}") do |progress|
+          validate_target!
+          progress.update(detail: 'reading widget package')
+          inventory = WidgetPackageInventory.read(archive)
+          validate_identity!(inventory, package)
+          digest = Digest::SHA256.file(archive).hexdigest
+          destination = safe_path(File.join('widgets', inventory.project_filename))
+          cache = safe_path(cache_relative(inventory, package))
+          lock_path = safe_path(File.join('.mxrb', 'marketplace.lock.json'))
+          current = validate_boundaries!(package, destination, cache, lock_path)
+          progress.update(detail: 'installing project assets')
+          install_transaction(
+            archive, package, inventory, digest, destination, cache, lock_path, current
+          )
+        end
       end
 
       private

data/lib/mxrb/official_marketplace.rb

@@ -223,14 +223,20 @@ module Mxrb
       end
 
       def json(url, authorization: default_authorization)
-        JSON.parse(get(url, accept: 'application/json', authorization:))
+        Progress.with('Loading Marketplace data') do |progress|
+          progress.update(detail: URI.parse(url).host)
+          JSON.parse(get(url, accept: 'application/json', authorization:))
+        end
       rescue JSON::ParserError => e
         raise MarketplaceError, "invalid JSON response: #{e.message}"
       end
 
       def download(url, destination, authorization: default_authorization)
-        File.binwrite(destination, get(url, accept: 'application/octet-stream', authorization:))
-        destination
+        Progress.with("Downloading #{File.basename(destination)}") do |progress|
+          progress.update(detail: URI.parse(url).host)
+          File.binwrite(destination, get(url, accept: 'application/octet-stream', authorization:))
+          destination
+        end
       end
 
       private