mxrb 0.1.3 → 0.1.4

data/lib/mxrb/widget_certification.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'json'
+require 'tmpdir'
+require 'zip'
+
+module Mxrb
+  # Fail-closed evidence gate for core and pluggable widgets used by an MPR.
+  # rubocop:disable Metrics
+  class WidgetCertification
+    CORE_WIDGET_TYPES = %w[
+      Forms$DivContainer Forms$LayoutGrid Forms$LayoutGridRow Forms$LayoutGridColumn Forms$Table
+      Forms$DynamicText Forms$Title Forms$ActionButton Forms$DataView Forms$ListView Forms$TextBox
+      Forms$TextArea Forms$DatePicker Forms$CheckBox Forms$RadioButtonGroup Forms$FileManager
+      Forms$GroupBox Forms$SnippetCallWidget Forms$Label Forms$TabControl Forms$StaticImageViewer
+      Forms$ScrollContainer Forms$Placeholder Forms$SidebarToggleButton Forms$Header
+      Forms$NavigationTree Forms$MenuBar Forms$SimpleMenuBar
+    ].freeze
+    FAILURE_MARKERS = [
+      'Could not render widget',
+      'An error occurred, please contact your system administrator.',
+      'Executing runtime operation failed for security reasons',
+      'Out of context', 'out of context', 'must be placed inside',
+      'should be placed within', 'failed to load'
+    ].freeze
+
+    def initialize(path, browser_report: nil, build: true, mendix_home: nil)
+      @path = File.expand_path(path)
+      @browser_report = browser_report && File.expand_path(browser_report)
+      @build = build
+      @mendix_home = mendix_home
+    end
+
+    def run
+      started = monotonic
+      source = Compiler::SourceModel.read(@path)
+      inventory = widget_inventory(source)
+      compilation = compile_pages(source)
+      package_inventory = packages(inventory.fetch(:custom).map { _1.fetch(:id) })
+      native_build = @build ? build_web(source.version) : { status: 'not_run' }
+      browser = browser_evidence(inventory)
+      failures = failures(compilation, package_inventory, native_build, browser)
+      {
+        path: @path, mendix_version: source.version,
+        status: failures.empty? ? 'pass' : 'fail', failures:,
+        inventory:, packages: package_inventory, compilation:, native_build:, browser:,
+        elapsed_seconds: (monotonic - started).round(3)
+      }
+    rescue StandardError => e
+      {
+        path: @path, status: 'fail', failures: [e.message],
+        error: { class: e.class.name, message: e.message },
+        elapsed_seconds: (monotonic - started).round(3)
+      }
+    end
+
+    private
+
+    def widget_inventory(source)
+      found = web_units(source).flat_map do |unit|
+        nested_widgets(unit.document).map do |widget|
+          custom = widget['$Type'] == 'CustomWidgets$CustomWidget'
+          {
+            page: "#{unit.module_name}.#{unit.document['Name']}", name: widget['Name'].to_s,
+            type: widget['$Type'].to_s, id: (custom ? custom_widget_id(source, widget) : nil)
+          }
+        end
+      end
+      core = found.reject { _1[:id] }.group_by { _1.fetch(:type) }.map do |type, entries|
+        { type:, occurrences: entries.length, pages: entries.map { _1.fetch(:page) }.uniq.sort }
+      end
+      core.sort_by! { _1.fetch(:type) }
+      custom = found.select { _1[:id] }.group_by { _1.fetch(:id) }.map do |id, entries|
+        { id:, occurrences: entries.length, pages: entries.map { _1.fetch(:page) }.uniq.sort }
+      end
+      custom.sort_by! { _1.fetch(:id) }
+      { total: found.length, core:, custom: }
+    end
+
+    def nested_widgets(value, found = [])
+      case value
+      when Hash
+        type = value['$Type'].to_s
+        found << value if CORE_WIDGET_TYPES.include?(type) || type == 'CustomWidgets$CustomWidget'
+        value.each_value { nested_widgets(_1, found) }
+      when Array then value.each { nested_widgets(_1, found) }
+      end
+      found
+    end
+
+    def custom_widget_id(source, widget)
+      direct = widget.dig('Type', 'WidgetId').to_s
+      return direct unless direct.empty?
+
+      pointer = IO::BsonCodec.extract_id(widget.dig('Object', 'TypePointer'))
+      source.document_index.values.find do |document|
+        IO::BsonCodec.extract_id(document.dig('ObjectType', '$ID')) == pointer
+      end&.fetch('WidgetId', '').to_s
+    end
+
+    def compile_pages(source)
+      pages = web_units(source).map do |unit|
+        bundle = if unit.document['$Type'] == 'Forms$Layout'
+                   Compiler::PageBundleCompiler.new(source).compile_layout(unit)
+                 else
+                   Compiler::PageBundleCompiler.new(source).compile(unit)
+                 end
+        {
+          name: bundle.qualified_name, bytes: bundle.source.bytesize,
+          unsupported: bundle.unsupported_widgets,
+          unsupported_custom: bundle.unsupported_custom_widgets
+        }
+      end
+      { status: pages.all? { _1[:unsupported].empty? && _1[:unsupported_custom].empty? } ? 'pass' : 'fail', pages: }
+    end
+
+    def packages(widget_ids)
+      paths = Dir.glob(File.join(File.dirname(@path), 'widgets', '*.mpk')).sort
+      entries = paths.map do |path|
+        modules = Zip::File.open(path) { _1.map(&:name).grep(/\.mjs\z/) }
+        ids = widget_ids.select { modules.include?("#{_1.tr('.', '/')}.mjs") }
+        next if ids.empty?
+
+        { file: File.basename(path), sha256: Digest::SHA256.file(path).hexdigest, widget_ids: ids.sort }
+      rescue Zip::Error => e
+        { file: File.basename(path), error: e.message, widget_ids: [] }
+      end.compact
+      covered = entries.flat_map { _1.fetch(:widget_ids) }.uniq
+      {
+        status: (widget_ids - covered).empty? ? 'pass' : 'fail', entries:,
+        missing_widget_ids: (widget_ids - covered).sort
+      }
+    end
+
+    def build_web(version)
+      root = @mendix_home || File.join(Dir.home, '.local', 'share', 'mendix', version)
+      started = monotonic
+      Dir.mktmpdir('mxrb-widget-certification-') do |directory|
+        deployment = File.join(directory, 'deployment')
+        stages = Compiler::DeploymentMaterializer.new(
+          @path, deployment:, mendix_home: root
+        ).materialize.stages.length
+        web = Compiler::WebBundleBuilder.new(
+          @path, deployment:, mendix_home: root
+        ).build
+        return {
+          status: 'pass', stages:, files: web.files, bytes: web.bytes,
+          elapsed_ms: ((monotonic - started) * 1000).round(1)
+        }
+      end
+    end
+
+    def browser_evidence(inventory)
+      required_ids = inventory.fetch(:custom).map { _1.fetch(:id) }
+      required_types = inventory.fetch(:core).map { _1.fetch(:type) }
+      return { status: 'missing', missing_widget_ids: required_ids, missing_widget_types: required_types } unless
+        @browser_report && File.file?(@browser_report)
+
+      report = JSON.parse(File.read(@browser_report))
+      declared = Array(report.dig('certification', 'widget_ids')).map(&:to_s).uniq
+      declared_types = Array(report.dig('certification', 'widget_types')).map(&:to_s).uniq
+      visible_failures = browser_failure_markers(report)
+      missing = required_ids - declared
+      missing_types = required_types - declared_types
+      status = if report['passed'] == true && visible_failures.empty? && missing.empty? && missing_types.empty?
+                 'pass'
+               else
+                 'fail'
+               end
+      {
+        status:, passed: report['passed'] == true, scenario: report['scenario'],
+        widget_ids: declared.sort, missing_widget_ids: missing.sort,
+        widget_types: declared_types.sort, missing_widget_types: missing_types.sort,
+        visible_failures:, console_errors: Array(report['console_errors']),
+        report: @browser_report
+      }
+    rescue JSON::ParserError => e
+      { status: 'fail', error: "invalid browser report: #{e.message}" }
+    end
+
+    def browser_failure_markers(report)
+      elements = Array(report['pages']).flat_map { Array(_1.dig('snapshot', 'elements')) } +
+                 Array(report.dig('failure_snapshot', 'elements'))
+      elements.filter_map do |element|
+        text = element['text'].to_s
+        text if FAILURE_MARKERS.any? { text.include?(_1) }
+      end.uniq
+    end
+
+    def failures(compilation, package_inventory, native_build, browser)
+      [].tap do |result|
+        result << 'page compiler reported unsupported widgets' unless compilation[:status] == 'pass'
+        result << 'one or more pluggable widget modules are missing' unless package_inventory[:status] == 'pass'
+        result << 'native web bundle did not pass' unless native_build[:status] == 'pass'
+        result << 'passing browser evidence does not cover every widget contract' unless browser[:status] == 'pass'
+      end
+    end
+
+    def web_units(source)
+      source.units_of('Forms$Page').select { source.web_page?(_1) } +
+        source.units_of('Forms$Layout').select { source.web_layout?(_1) }
+    end
+
+    def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+  # rubocop:enable Metrics
+end

data/lib/mxrb/writer.rb

@@ -47,7 +47,9 @@ module Mxrb
         mpr = IO::MprFile.open(@path)
         mpr.transaction do
           apply(mpr, native_units)
+          write_native_compatibility(mpr, native_units)
           mpr.write_architecture_definition(@definition)
+          mpr.write_ruby_app_sources(ruby_app_source_files) if @definition[:ruby_app_sources_path]
         end
         progress.advance(detail: "model transaction")
         materialize_project_assets(asset_manifest)
@@ -62,6 +64,22 @@ module Mxrb
 
     private
 
+    def ruby_app_source_files
+      path = @definition.fetch(:ruby_app_sources_path)
+      manifest = JSON.parse(File.read(path))
+      manifest.fetch("files").map do |file|
+        relative = safe_asset_path(file.fetch("path"))
+        contents = Base64.strict_decode64(file.fetch("contents"))
+        checksum = Digest::SHA256.hexdigest(contents)
+        raise SerializationError, "Ruby source checksum mismatch: #{relative}" \
+          unless checksum == file.fetch("sha256")
+
+        { path: relative, contents:, sha256: checksum, mode: file.fetch("mode", 0o644) }
+      end
+    rescue JSON::ParserError, KeyError, ArgumentError => e
+      raise SerializationError, "invalid Ruby source manifest: #{e.message}"
+    end
+
     def materialize_design_system
       design_system = @definition[:design_system]
       return unless design_system
@@ -352,7 +370,8 @@ module Mxrb
         if existing
           current = mpr.parse_contents(existing)
           preserved = current.merge(doc).merge(
-            '$ID' => current['$ID'] || existing.fetch('UnitID'), '$Type' => doc.fetch('$Type')
+            '$ID' => current['$ID'] || existing.fetch('UnitID'),
+            '$Type' => doc['$Type'] || doc[:'$Type'] || document.fetch(:type)
           )
           mpr.update_unit(existing.fetch('UnitID'), preserved)
           next
@@ -431,26 +450,59 @@ module Mxrb
     def upsert_native_unit(mpr, container_id, unit)
       doc = unit.fetch("doc")
       name = doc["Name"] || doc["name"]
-      existing = if name.to_s.empty?
-        mpr.children_of(container_id).find { mpr.parse_contents(_1)["$Type"] == doc["$Type"] }
-      else
-        mpr.children_of(container_id).find do |raw|
-          existing_doc = mpr.parse_contents(raw)
-          (existing_doc["Name"] || existing_doc["name"]) == name && existing_doc["$Type"] == doc["$Type"]
-        end
-      end
+      requested_id = unit["unit_id"].to_s
+      requested_id = nil if requested_id.empty?
+      stable = mpr.unit(requested_id) if requested_id
+      existing = stable if stable && mpr.parse_contents(stable)["$Type"] == doc["$Type"]
+      candidates = mpr.children_of(container_id)
+      existing ||= if name.to_s.empty?
+                     candidates.find { mpr.parse_contents(_1)["$Type"] == doc["$Type"] }
+                   else
+                     candidates.find do |raw|
+                       existing_doc = mpr.parse_contents(raw)
+                       (existing_doc["Name"] || existing_doc["name"]) == name &&
+                         existing_doc["$Type"] == doc["$Type"]
+                     end
+                   end
       if existing
         current = mpr.parse_contents(existing)
         preserved = {
           "$ID" => current["$ID"] || existing.fetch("UnitID"),
           "$Type" => doc["$Type"]
         }.merge(current).merge(doc)
+        preserved["$ID"] = current["$ID"] || existing.fetch("UnitID") unless existing.equal?(stable)
         mpr.update_unit(existing.fetch("UnitID"), preserved)
         existing.fetch("UnitID")
       else
         containment = unit.fetch("containment")
-        mpr.insert_unit(container_uuid: container_id, containment_name: containment, contents_doc: doc)
+        inserted_id = stable ? SecureRandom.uuid : requested_id
+        inserted_doc = stable ? doc.merge("$ID" => inserted_id) : doc
+        mpr.insert_unit(
+          container_uuid: container_id,
+          containment_name: containment,
+          contents_doc: inserted_doc,
+          unit_uuid: inserted_id
+        )
+      end
+    end
+
+    def write_native_compatibility(mpr, native_units)
+      mismatches = native_units.filter_map do |unit|
+        unit_id = unit["unit_id"].to_s
+        doc = unit.fetch("doc")
+        content_id = IO::BsonCodec.extract_id(doc["$ID"]).to_s
+        next if unit_id.empty? || content_id.empty? || unit_id == content_id
+
+        raw = mpr.unit(unit_id)
+        next unless raw
+
+        written = mpr.parse_contents(raw)
+        written_id = IO::BsonCodec.extract_id(written["$ID"]).to_s
+        next unless written_id == content_id && written["$Type"] == doc["$Type"]
+
+        { unit_id: unit_id, content_id: content_id, type: doc["$Type"] }
       end
+      mpr.write_legacy_unit_identity_mismatches(mismatches)
     end
 
     def write_project_security(mpr, root_id, security)
@@ -899,6 +951,7 @@ module Mxrb
       doc.delete("__mxrb_preserve_native_body")
       doc.delete("__mxrb_deep_structure_declared")
       doc.delete("__mxrb_allow_concurrent_execution_declared")
+      doc.delete("__mxrb_apply_entity_access_declared")
       doc.delete("__mxrb_mark_as_used_declared")
       doc.delete("__mxrb_excluded_declared")
       strip_nested_internal_keys(doc)
@@ -935,15 +988,61 @@ module Mxrb
     def configure_pluggable_widget!(widget, options)
       properties = custom_widget_properties(widget)
       options.fetch(:properties, {}).each do |key, configured|
-        value = properties.dig(key.to_s, "Value")
-        next unless value
+        property = properties[key.to_s]
+        configure_custom_widget_value!(property, configured) if property
+      end
+    end
+
+    def configure_custom_widget_value!(property, configured)
+      value = property.fetch('Value')
+      unless configured.is_a?(Hash)
+        value['PrimitiveValue'] = configured.to_s unless configured.nil?
+        return value
+      end
+      return value.merge!(stringify_keys(configured)) unless semantic_widget_value?(configured)
+
+      configured = configured.to_h { |key, item| [key.to_sym, item] }
+      value['PrimitiveValue'] = configured[:primitive].to_s if configured.key?(:primitive)
+      value['Expression'] = configured[:expression].to_s if configured.key?(:expression)
+      value['Selection'] = configured[:selection].to_s if configured.key?(:selection)
+      value['TextTemplate'] = client_template_doc(configured[:text]) if configured.key?(:text)
+      value['AttributeRef'] = attribute_ref_doc(configured[:attribute]) if configured.key?(:attribute)
+      value['EntityRef'] = indirect_entity_ref_doc(configured[:association]) if configured.key?(:association)
+      configure_widget_data_source!(value, configured[:data_source]) if configured.key?(:data_source)
+      configure_widget_children!(value, configured[:widgets]) if configured.key?(:widgets)
+      configure_widget_objects!(property, value, configured[:objects]) if configured.key?(:objects)
+      value
+    end
+
+    def semantic_widget_value?(value)
+      value.is_a?(Hash) && (value.keys.map(&:to_sym) & %i[
+        primitive expression selection text attribute association data_source widgets objects
+      ]).any?
+    end
+
+    def configure_widget_data_source!(value, configured)
+      options = configured.is_a?(Hash) ? configured : { entity: configured }
+      value['DataSource'] = custom_xpath_source_doc(
+        options.fetch(:entity), xpath: options.fetch(:xpath, '')
+      )
+    end
+
+    def configure_widget_children!(value, widgets)
+      children = (widgets.is_a?(Array) ? widgets : [widgets]).compact.map { widget_doc(_1) }
+      value['Widgets'] = IO::BsonCodec.build_array(children, marker: 2)
+    end
 
-        if configured.is_a?(Hash)
-          value.merge!(stringify_keys(configured))
-        elsif !configured.nil?
-          value["PrimitiveValue"] = configured.to_s
+    def configure_widget_objects!(property, value, configurations)
+      object_type = property.dig('ValueType', 'ObjectType')
+      objects = Array(configurations).map do |configuration|
+        object = custom_widget_object_doc(object_type)
+        nested = widget_object_properties(object_type, object)
+        configuration.each do |key, configured|
+          configure_custom_widget_value!(nested.fetch(key.to_s), configured)
         end
+        object
       end
+      value['Objects'] = IO::BsonCodec.build_array(objects, marker: 2)
     end
 
     def stringify_keys(value)
@@ -987,6 +1086,15 @@ module Mxrb
       if options[:entity] && properties["datasource"]
         properties["datasource"]["Value"]["DataSource"] = custom_xpath_source_doc(options[:entity])
       end
+      if options[:selection] && properties['itemSelection']
+        properties.dig('itemSelection', 'Value')['Selection'] = options[:selection].to_s
+      end
+      if properties['filtersPlaceholder'] && options[:filters]
+        configured_filters = options[:filters].is_a?(Array) ? options[:filters] : [options[:filters]]
+        filters = configured_filters.map { widget_doc(_1) }
+        properties.dig('filtersPlaceholder', 'Value')['Widgets'] =
+          IO::BsonCodec.build_array(filters, marker: 2)
+      end
       return unless properties["columns"] && options[:columns]
 
       column_type = properties["columns"].dig("ValueType", "ObjectType")
@@ -1052,16 +1160,20 @@ module Mxrb
     end
 
     def custom_widget_properties(widget)
-      types = array_items(widget.dig("Type", "ObjectType", "PropertyTypes")).to_h do |type|
+      widget_object_properties(widget.dig('Type', 'ObjectType'), widget['Object'])
+    end
+
+    def widget_object_properties(object_type, object)
+      types = array_items(object_type&.fetch('PropertyTypes', nil)).to_h do |type|
         [IO::BsonCodec.extract_id(type["$ID"]), type]
       end
-      array_items(widget.dig("Object", "Properties")).to_h do |property|
+      array_items(object&.fetch('Properties', nil)).to_h do |property|
         type = types[IO::BsonCodec.extract_id(property["TypePointer"])]
         [type && type["PropertyKey"], property.merge("ValueType" => type && type["ValueType"])]
       end.compact
     end
 
-    def custom_xpath_source_doc(entity)
+    def custom_xpath_source_doc(entity, xpath: '')
       {
         "$ID" => SecureRandom.uuid, "$Type" => "CustomWidgets$CustomWidgetXPathSource",
         "EntityRef" => {
@@ -1073,19 +1185,24 @@ module Mxrb
           "$ID" => SecureRandom.uuid, "$Type" => "Forms$GridSortBar",
           "SortItems" => IO::BsonCodec.build_array([], marker: 2)
         },
-        "SourceVariable" => nil, "XPathConstraint" => ""
+        "SourceVariable" => nil, "XPathConstraint" => xpath.to_s
       }
     end
 
     def data_grid2_column_doc(object_type, column, entity: nil)
       attribute = column[:attribute]
       attribute = "#{entity}.#{attribute}" if entity && attribute && !attribute.include?('.')
+      filters = column[:filter].is_a?(Array) ? column[:filter] : [column[:filter]].compact
       overrides = {
         "showContentAs" => { "PrimitiveValue" => "attribute" },
         "attribute" => { "AttributeRef" => attribute_ref_doc(attribute) },
         "header" => { "TextTemplate" => client_template_doc(column[:caption] || column[:name]) },
         "tooltip" => { "TextTemplate" => empty_client_template_doc },
-        "filter" => { "TextTemplate" => empty_client_template_doc }
+        "filter" => {
+          "Widgets" => IO::BsonCodec.build_array(
+            filters.map { widget_doc(_1) }, marker: 2
+          )
+        }
       }
       custom_widget_object_doc(object_type, overrides)
     end
@@ -1131,6 +1248,7 @@ module Mxrb
     def preserve_flow_metadata(merged, existing, generated)
       {
         "AllowConcurrentExecution" => "__mxrb_allow_concurrent_execution_declared",
+        "ApplyEntityAccess" => "__mxrb_apply_entity_access_declared",
         "MarkAsUsed" => "__mxrb_mark_as_used_declared",
         "Excluded" => "__mxrb_excluded_declared"
       }.each do |field, declaration|
@@ -1459,7 +1577,7 @@ module Mxrb
     end
 
     def attribute_doc(attr, previous)
-      storage_type = Model::Attribute::TYPE_MAP.fetch(attr.fetch(:type))
+      storage_type = Model::Attribute::TYPE_MAP.fetch(attr.fetch(:type).to_sym)
       type_key = native_existing_key(previous, "type", "Type", "newType", "NewType") || "NewType"
       value_key = native_existing_key(previous, "value", "Value") || "Value"
       name_key = native_key(previous, "name", "Name")
@@ -1471,9 +1589,11 @@ module Mxrb
         { "$ID" => SecureRandom.uuid, "$Type" => storage_type }
       end
       type_doc = type_doc.merge("Enumeration" => attr[:enumeration].to_s) if attr[:enumeration]
-      if attr[:length]
+      string_type = storage_type == Model::Attribute::TYPE_MAP[:string]
+      if attr[:length] || (string_type && !previous_type&.key?('length') && !previous_type&.key?('Length'))
         length_key = native_key(previous_type, 'length', 'Length')
-        type_doc = type_doc.merge(length_key => Integer(attr[:length]))
+        length = attr[:length] || Model::Attribute::DEFAULT_STRING_LENGTH
+        type_doc = type_doc.merge(length_key => Integer(length))
       end
       if attr.key?(:localize_date)
         localize_key = native_key(previous_type, 'localizeDate', 'LocalizeDate')
@@ -2259,6 +2379,48 @@ module Mxrb
       }
     end
 
+    # A project created outside Studio Pro may not have the pluggable-widget
+    # package available yet. These standard-shaped fallback fields preserve
+    # the concise Ruby projection until Studio Pro can hydrate the widget.
+    def configure_fallback_data_grid!(doc, options)
+      entity = options[:entity].to_s
+      columns = Array(options[:columns]).map do |column|
+        attribute = column[:attribute].to_s
+        attribute = "#{entity}.#{attribute}" if !entity.empty? && !attribute.empty? && !attribute.include?('.')
+        {
+          '$ID' => SecureRandom.uuid, '$Type' => 'Forms$DataGridColumn',
+          'Name' => column[:name].to_s,
+          'AttributeRef' => attribute_ref_doc(attribute),
+          'Caption' => text_doc(column[:caption] || column[:name])
+        }
+      end
+      toolbar = Array(options.dig(:toolbar, :buttons)).map do |button|
+        kind = { new: 'New', delete: 'Delete', search: 'Search', export: 'ExportToExcel' }
+               .fetch(button[:type].to_sym)
+        {
+          '$ID' => SecureRandom.uuid, '$Type' => "Forms$Grid#{kind}Button",
+          'Caption' => text_doc(button[:caption].to_s)
+        }
+      end
+      doc['DataSource'] = {
+        '$ID' => SecureRandom.uuid, '$Type' => 'Forms$DatabaseSource', 'Entity' => entity
+      }
+      doc['Columns'] = IO::BsonCodec.build_array(columns)
+      doc['ToolBar'] = {
+        '$ID' => SecureRandom.uuid, '$Type' => 'Forms$GridControlBar',
+        'Buttons' => IO::BsonCodec.build_array(toolbar)
+      }
+      doc
+    end
+
+    def configure_fallback_combo_box!(doc, options)
+      doc['AttributePath'] = options[:attribute].to_s if options[:attribute]
+      doc['LabelText'] = text_doc(options[:caption]) if options.key?(:caption)
+      doc['SelectorType'] = options[:__kind].to_sym == :reference_selector ? 'Reference' : 'Enumeration'
+      doc['DisplayAttribute'] = options[:display_attribute].to_s if options[:display_attribute]
+      doc
+    end
+
     def combo_box_descriptor
       {
         id: "com.mendix.widget.web.combobox.Combobox", name: "Combo box",
@@ -2305,6 +2467,15 @@ module Mxrb
       configure_data_grid2!(doc, options) if descriptor.fetch(:id) == data_grid2_descriptor[:id]
       configure_combo_box!(doc, options) if descriptor.fetch(:id) == combo_box_descriptor[:id]
       configure_pluggable_widget!(doc, options) if widget.fetch(:type) == :pluggable_widget
+      if definition.nil? && descriptor.fetch(:id) == data_grid2_descriptor[:id]
+        configure_fallback_data_grid!(doc, options)
+      end
+      if definition.nil? && descriptor.fetch(:id) == combo_box_descriptor[:id]
+        configure_fallback_combo_box!(doc, options)
+      end
+      widget.fetch(:events, []).each do |event|
+        doc[event_property(event.fetch(:event))] = client_action_doc(event)
+      end
       doc
     end
 
@@ -2465,6 +2636,8 @@ module Mxrb
       case event.fetch(:kind).to_sym
       when :action
         native_action_doc(event.fetch(:handler))
+      when :page
+        form_action_doc(event.fetch(:handler))
       when :nanoflow
         {
           "$ID" => SecureRandom.uuid,
@@ -2584,6 +2757,7 @@ module Mxrb
       body_declared   = !flow[:body].nil? || !flow[:return_expression].nil?
       return_var_name = flow[:return_variable_name] || "ReturnValue"
       allow_concurrent = flow[:allow_concurrent_execution]
+      apply_entity_access = flow[:apply_entity_access]
       mark_as_used = flow[:mark_as_used]
       excluded = flow[:excluded]
 
@@ -2601,6 +2775,7 @@ module Mxrb
         "Name" => flow_name, "Documentation" => flow.fetch(:documentation, ""),
         "ReturnVariableName" => return_var_name,
         "AllowConcurrentExecution" => allow_concurrent.nil? ? true : allow_concurrent,
+        "ApplyEntityAccess" => apply_entity_access.nil? ? false : apply_entity_access,
         "MarkAsUsed" => mark_as_used.nil? ? false : mark_as_used,
         "Excluded" => excluded.nil? ? false : excluded,
         "AllowedModuleRoles" => IO::BsonCodec.build_array(Array(flow[:allowed_roles]), marker: 1),
@@ -2608,6 +2783,7 @@ module Mxrb
         "__mxrb_body_declared" => body_declared,
         "__mxrb_preserve_native_body" => flow[:preserve_native_body] == true,
         "__mxrb_allow_concurrent_execution_declared" => !allow_concurrent.nil?,
+        "__mxrb_apply_entity_access_declared" => !apply_entity_access.nil?,
         "__mxrb_mark_as_used_declared" => !mark_as_used.nil?,
         "__mxrb_excluded_declared" => !excluded.nil?,
         "MicroflowReturnType" => microflow_data_type_doc(flow[:return_type], module_name),

data/lib/mxrb.rb

@@ -2,10 +2,12 @@
 
 require_relative "mxrb/version"
 require_relative "mxrb/errors"
+require_relative "mxrb/http/server"
 require_relative "mxrb/progress"
 require_relative "mxrb/doctor"
 require_relative "mxrb/benchmark"
 require_relative "mxrb/project_lifecycle"
+require_relative "mxrb/environment"
 require_relative "mxrb/scaffold/templates"
 require_relative "mxrb/scaffold/page_templates"
 require_relative "mxrb/initializer"
@@ -16,8 +18,11 @@ require_relative "mxrb/scaffold/recipes"
 require_relative "mxrb/scaffold/generator"
 require_relative "mxrb/scaffold/help"
 require_relative "mxrb/scaffold/cli"
+require_relative "mxrb/cli/help"
+require_relative "mxrb/cli/release"
 require_relative "mxrb/io/bson_codec"
 require_relative "mxrb/widget_package"
+require_relative "mxrb/widget_certification"
 require_relative "mxrb/frontend/migrator"
 require_relative "mxrb/io/mxunit_codec"
 require_relative "mxrb/io/mpr_file"
@@ -36,6 +41,13 @@ require_relative "mxrb/model/design_migration"
 require_relative "mxrb/model/module"
 require_relative "mxrb/model/connector"
 require_relative "mxrb/model/project"
+require_relative "mxrb/modeler/catalog"
+require_relative "mxrb/domain_diagram"
+require_relative "mxrb/domain_diagram/lifecycle"
+require_relative "mxrb/uml/class_diagram"
+require_relative "mxrb/uml/activity_diagram"
+require_relative "mxrb/uml/sequence_diagram"
+require_relative "mxrb/uml/server"
 require_relative "mxrb/protocols"
 require_relative "mxrb/oql"
 require_relative "mxrb/oql/plan_analyzer"
@@ -116,6 +128,7 @@ require_relative "mxrb/compiler/image_bundle_compiler"
 require_relative "mxrb/compiler/generic_widget_bundle_compiler"
 require_relative "mxrb/compiler/combo_box_bundle_compiler"
 require_relative "mxrb/compiler/legacy_data_grid_compiler"
+require_relative "mxrb/compiler/legacy_custom_widget_compiler"
 require_relative "mxrb/compiler/legacy_page_builder"
 require_relative "mxrb/compiler/page_bundle_compiler"
 require_relative "mxrb/compiler/compatibility_analyzer"
@@ -126,6 +139,14 @@ require_relative "mxrb/widget_synchronizer"
 require_relative "mxrb/runtime/docker_workspace"
 require_relative "mxrb/runtime/executor"
 require_relative "mxrb/runtime/native"
+require_relative "mxrb/runtime/schema_migrator"
+require_relative "mxrb/runtime/sqlite_store"
+require_relative "mxrb/runtime/access_control"
+require_relative "mxrb/runtime/shared_store"
+require_relative "mxrb/runtime/scheduler"
+require_relative "mxrb/ruby_app"
+require_relative "mxrb/ruby_app/preset"
+require_relative "mxrb/ruby_app/exporter"
 require_relative "mxrb/runtime/docker_executor"
 require_relative "mxrb/runtime/clipboard"
 require_relative "mxrb/runtime/database_workspace"
@@ -169,9 +190,13 @@ module Mxrb
   #
   def self.define(path, &block)
     output = ENV.fetch("MXRB_OUTPUT_PATH", path)
-    Dsl::Builder.new(output).tap { _1.instance_eval(&block) }.build!
+    builder = Dsl::Builder.new(output).tap { _1.instance_eval(&block) }.build!
+    @last_defined_path = builder.path
+    builder
   end
 
+  def self.last_defined_path = @last_defined_path
+
   def self.validate(path)
     Integrity::Validator.new(path).validate
   end