mxrb 0.1.3 → 0.1.5

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,187 @@ 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")
+        widget_id = widget.dig("Type", "WidgetId").to_s
+        return native_widget(widget) if widget_id.empty?
+
+        case widget_id
         when "com.mendix.widget.web.datagrid.Datagrid" then data_grid2_widget(widget)
         when "com.mendix.widget.web.combobox.Combobox"  then combo_box_widget(widget)
-        else native_widget(widget)
+        when "com.mendix.widget.web.gallery.Gallery"    then gallery_widget(widget)
+        else generic_pluggable_widget(widget)
+        end
+      end
+
+      def generic_pluggable_widget(widget)
+        object_type = widget.dig("Type", "ObjectType")
+        properties = pluggable_properties(widget["Object"], object_type)
+        children = nested_pluggable_widgets(properties)
+        properties = strip_pluggable_widgets(properties)
+        options = appearance_options(widget).merge(
+          widget_id: widget.dig("Type", "WidgetId"),
+          widget_name: widget.dig("Type", "WidgetName"),
+          platform: widget.dig("Type", "SupportedPlatform"),
+          properties:
+        ).compact
+        {
+          type: :pluggable_widget, name: widget["Name"] || "widget",
+          options:, children:, events: pluggable_events(properties)
+        }
+      end
+
+      def pluggable_properties(object, object_type)
+        return {} unless object.is_a?(Hash) && object_type.is_a?(Hash)
+
+        types = parse_array(object_type["PropertyTypes"])
+        types_by_id = types.to_h { [IO::BsonCodec.extract_id(_1["$ID"]), _1] }
+        parse_array(object["Properties"]).each_with_object({}) do |property, result|
+          type = types_by_id[IO::BsonCodec.extract_id(property["TypePointer"])]
+          next unless type
+
+          result[type["PropertyKey"].to_s] = pluggable_value(
+            property["Value"], type["ValueType"]
+          )
+        end
+      end
+
+      def pluggable_value(value, value_type)
+        return nil unless value.is_a?(Hash)
+
+        type = value_type.is_a?(Hash) ? value_type["Type"].to_s : ""
+        widgets = parse_array(value["Widgets"])
+        unless widgets.empty?
+          parsed = []
+          parse_widgets(widgets, parsed)
+          return { widgets: parsed }
+        end
+        objects = parse_array(value["Objects"])
+        unless objects.empty?
+          object_type = value_type.is_a?(Hash) ? value_type["ObjectType"] : nil
+          return { objects: objects.map { pluggable_properties(_1, object_type) } }
+        end
+
+        return extract_text(value["TextTemplate"]) if value["TextTemplate"].is_a?(Hash)
+        return value.dig("AttributeRef", "Attribute") if value["AttributeRef"].is_a?(Hash)
+        return pluggable_data_source(value["DataSource"]) if value["DataSource"].is_a?(Hash)
+        return value["Expression"] unless value["Expression"].to_s.empty?
+        return value["Image"] unless value["Image"].to_s.empty?
+        return value["Form"] unless value["Form"].to_s.empty?
+
+        primitive = value["PrimitiveValue"]
+        return primitive == true || primitive.to_s.casecmp("true").zero? if type == "Boolean"
+        return primitive.to_i if type == "Integer"
+        return primitive.to_f if %w[Decimal Number].include?(type)
+        return primitive unless primitive.nil? || primitive.to_s.empty?
+
+        action = value["Action"]
+        return pluggable_action(action) if action.is_a?(Hash) && action["$Type"] != "Forms$NoAction"
+        return value["Selection"] unless value["Selection"].to_s.empty? || value["Selection"] == "None"
+
+        nil
+      end
+
+      def pluggable_data_source(source)
+        {
+          data_source: source.dig("EntityRef", "Entity") || source["Entity"],
+          xpath: source["XPathConstraint"].to_s,
+          sort: parse_array(source.dig("SortBar", "SortItems")).map do |item|
+            {
+              attribute: item.dig("AttributeRef", "Attribute"),
+              direction: item["SortDirection"].to_s
+            }.compact
+          end
+        }.compact
+      end
+
+      def pluggable_action(action)
+        candidates = {
+          "nanoflow" => action["Nanoflow"],
+          "microflow" => action["Microflow"],
+          "page" => action["Form"]
+        }
+        kind, handler = candidates.find { |_candidate, value| !value.to_s.empty? }
+        kind ||= "action"
+        handler ||= action["$Type"]
+        { kind:, handler: handler.to_s }
+      end
+
+      def nested_pluggable_widgets(value, found = [])
+        case value
+        when Hash
+          widgets = value[:widgets] || value["widgets"]
+          found.concat(Array(widgets)) if widgets
+          value.each_value { nested_pluggable_widgets(_1, found) }
+        when Array then value.each { nested_pluggable_widgets(_1, found) }
+        end
+        found.uniq { [_1[:name] || _1["name"], _1[:type] || _1["type"]] }
+      end
+
+      def strip_pluggable_widgets(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, child), result|
+            next if key.to_s == "widgets"
+
+            result[key] = strip_pluggable_widgets(child)
+          end
+        when Array then value.map { strip_pluggable_widgets(_1) }
+        else value
+        end
+      end
+
+      def pluggable_events(properties)
+        properties.filter_map do |key, value|
+          next unless value.is_a?(Hash) && value[:handler]
+
+          event = key.to_s.match?(/change/i) ? :on_change : :on_click
+          value.merge(event:)
+        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 +433,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 +479,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 +588,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