mxrb 0.1.0

data/lib/mxrb/model/microflow.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "unit"
+
+module Mxrb
+  module Model
+    # $Type: Microflows$Microflow
+    # ContainmentName: "Documents"
+    class Microflow < Unit
+      attr_reader :name, :documentation, :return_variable_name,
+                  :allow_concurrent_execution, :mark_as_used, :excluded,
+                  :allowed_module_roles, :parameters, :return_type,
+                  :objects, :flows
+
+      def decode(doc)
+        @name                       = doc["Name"] || doc["name"]
+        @documentation              = doc["Documentation"] || doc["documentation"] || ""
+        @return_variable_name       = doc["ReturnVariableName"] || "ReturnValue"
+        @allow_concurrent_execution = doc["AllowConcurrentExecution"] != false
+        @mark_as_used               = doc["MarkAsUsed"] == true
+        @excluded                   = doc["Excluded"] == true
+        @allowed_module_roles       = parse_array(doc["AllowedModuleRoles"])
+        @parameters                 = extract_parameters(doc)
+        return_doc                  = doc["MicroflowReturnType"] || doc["ReturnType"]
+        @return_type                = return_doc.is_a?(Hash) ? (return_doc["$Type"] || return_doc["Type"]) : return_doc
+
+        obj_col = doc["ObjectCollection"] || {}
+        @objects = parse_array(obj_col["Objects"] || obj_col["objects"] || obj_col)
+        # Mendix stores all sequence flows (including flows inside looped
+        # activities) at document level. Older MXRB-generated documents used
+        # ObjectCollection/Flows, so keep that as a compatibility fallback.
+        @flows   = parse_array(
+          doc["Flows"] || doc["flows"] ||
+          obj_col["Flows"] || obj_col["flows"] || []
+        )
+      end
+
+      def to_bson
+        {
+          "$ID"                       => @id,
+          "$Type"                     => "Microflows$Microflow",
+          "Name"                      => @name,
+          "Documentation"             => @documentation || "",
+          "ReturnVariableName"        => @return_variable_name || "ReturnValue",
+          "AllowConcurrentExecution"  => @allow_concurrent_execution != false,
+          "MarkAsUsed"                => @mark_as_used || false,
+          "Excluded"                  => @excluded || false,
+          "AllowedModuleRoles"        => IO::BsonCodec.build_array(@allowed_module_roles || [], marker: 1),
+          "MicroflowParameterCollection" => serialize_parameters,
+          "MicroflowReturnType"       => @return_type || default_void_return,
+          "ObjectCollection"          => serialize_object_collection,
+          "Flows"                     => IO::BsonCodec.build_array(@flows || []),
+        }
+      end
+
+      def inspect
+        "#<Mxrb::Microflow name=#{@name.inspect} objects=#{@objects.size} flows=#{@flows.size}>"
+      end
+
+      private
+
+      def extract_parameters(doc)
+        pc = doc["MicroflowParameterCollection"] || doc["Parameters"] || {}
+        if pc.is_a?(Hash) && (pc["Parameters"] || !pc.empty?)
+          list = parse_array(pc["Parameters"] || [])
+          return list unless list.empty?
+        end
+        # MXRB writer embeds parameters inside ObjectCollection.Objects
+        obj_col = doc["ObjectCollection"] || {}
+        all_objects = parse_array(obj_col["Objects"] || obj_col["objects"] || obj_col)
+        all_objects.select { |o| o.is_a?(Hash) && (o["$Type"] || o["\$Type"]) == "Microflows$MicroflowParameter" }
+      end
+
+      def serialize_parameters
+        {
+          "$ID"        => SecureRandom.uuid,
+          "$Type"      => "Microflows$MicroflowParameterCollection",
+          "Parameters" => IO::BsonCodec.build_array(@parameters || []),
+        }
+      end
+
+      def default_void_return
+        {
+          "$ID"            => SecureRandom.uuid,
+          "$Type"          => "Microflows$MicroflowReturnType",
+          "Type"           => nil,
+          "AllowedModuleRoles" => IO::BsonCodec.build_array([], marker: 1),
+        }
+      end
+
+      def serialize_object_collection
+        {
+          "$ID"     => SecureRandom.uuid,
+          "$Type"   => "Microflows$MicroflowObjectCollection",
+          "Objects" => IO::BsonCodec.build_array(@objects || []),
+        }
+      end
+    end
+  end
+end

data/lib/mxrb/model/module.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative "unit"
+
+module Mxrb
+  module Model
+    # $Type: Projects$Module
+    # ContainmentName: "Modules"
+    class Module < Unit
+      attr_reader :name, :sort_index, :from_app_store,
+                  :app_store_guid, :app_store_version, :export_level
+
+      def decode(doc)
+        @name              = doc["Name"]
+        @sort_index        = doc["SortIndex"] || doc["NewSortIndex"]
+        @from_app_store    = doc["FromAppStore"] == true
+        @app_store_guid    = doc["AppStoreGuid"]
+        @app_store_version = doc["AppStoreVersion"]
+        @export_level      = doc["ExportLevel"] || "Hidden"
+      end
+
+      def to_bson
+        {
+          "$ID"          => @id,
+          "$Type"        => "Projects$Module",
+          "Name"         => @name,
+          "SortIndex"    => @sort_index || 0,
+          "FromAppStore" => @from_app_store || false,
+          "ExportLevel"  => @export_level || "Hidden",
+        }
+      end
+
+      # ── Children (resolved from Unit table by ContainerID) ────────────
+
+      def domain_model
+        @domain_model ||= begin
+          raws = @mpr.units_by_containment("DomainModel").select { _1["ContainerID"] == @id }
+          raws.empty? ? nil : DomainModel.new(raws.first, @mpr)
+        end
+      end
+
+      def entities    = domain_model&.entities    || []
+      def associations = domain_model&.associations || []
+
+      def pages
+        @pages ||= document_units
+                   .select { |u| %w[Pages$Page Forms$Page].include?(u[:type]) }
+                   .map { Page.new(_1[:raw], @mpr) }
+      end
+
+      def microflows
+        @microflows ||= document_units
+                        .select { |u| u[:type] == "Microflows$Microflow" }
+                        .map { Microflow.new(_1[:raw], @mpr) }
+      end
+
+      def nanoflows
+        @nanoflows ||= document_units
+                       .select { |u| u[:type] == "Microflows$Nanoflow" }
+                       .map { Microflow.new(_1[:raw], @mpr) }
+      end
+
+      def menus
+        @menus ||= document_units
+                   .select { |u| u[:type] == "Menus$MenuDocument" }
+                   .map { Menu.new(_1[:raw], @mpr) }
+      end
+
+      def enumerations
+        @enumerations ||= document_units
+                          .select { |u| u[:type] == "Enumerations$Enumeration" }
+                          .map { unit_to_doc(_1) }
+      end
+
+      def constants
+        @constants ||= document_units
+                       .select { |u| u[:type] == "Constants$Constant" }
+                       .map { unit_to_doc(_1) }
+      end
+
+      def scheduled_events
+        @scheduled_events ||= document_units
+                              .select { |u| u[:type] == "ScheduledEvents$ScheduledEvent" }
+                              .map { unit_to_doc(_1) }
+      end
+
+      def module_roles
+        @module_roles ||= begin
+          raw = @mpr.children_of(@id).find { _1["ContainmentName"] == "ModuleSecurity" }
+          if raw
+            doc = @mpr.parse_contents(raw)
+            parse_array(doc["ModuleRoles"]).map do |role|
+              { name: role["Name"], description: role["Description"].to_s }
+            end
+          else
+            []
+          end
+        end
+      end
+
+      def inspect
+        "#<Mxrb::Module name=#{@name.inspect} entities=#{entities.size} " \
+          "pages=#{pages.size} microflows=#{microflows.size}>"
+      end
+
+      private
+
+      def unit_to_doc(unit_hash)
+        @mpr.parse_contents(unit_hash[:raw])
+      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
+        @document_units ||= begin
+          collect_documents(@id).map do |raw|
+            doc  = @mpr.parse_contents(raw)
+            type = doc["$Type"]
+            { raw: raw, type: type }
+          end
+        end
+      end
+
+      def children_with_containment(name)
+        @mpr.units_by_containment(name).select { _1["ContainerID"] == @id }
+      end
+
+      def collect_documents(parent_id)
+        @mpr.children_of(parent_id).flat_map do |raw|
+          case raw["ContainmentName"]
+          when "Documents"
+            [raw]
+          when "Folders"
+            collect_documents(raw.fetch("UnitID"))
+          else
+            []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mxrb/model/navigation.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Model
+    # Typed reader for modern and legacy native Mendix navigation documents.
+    class Navigation
+      LEGACY_PROFILES = {
+        'DesktopProfile' => 'Desktop',
+        'TabletProfile' => 'Tablet',
+        'PhoneProfile' => 'Phone',
+        'OfflinePhoneProfile' => 'OfflinePhone',
+        'HybridPhoneProfile6' => 'HybridPhone',
+        'HybridTabletProfile6' => 'HybridTablet'
+      }.freeze
+
+      attr_reader :raw_document
+
+      def initialize(raw_document)
+        @raw_document = raw_document || {}
+      end
+
+      def profiles
+        @profiles ||= begin
+          modern = items(@raw_document['Profiles'])
+          documents = modern.empty? ? legacy_profile_documents : modern
+          documents.map { NavigationProfile.new(_1) }.freeze
+        end
+      end
+
+      def empty? = @raw_document.empty?
+      def to_h = { profiles: profiles.map(&:to_h) }
+
+      private
+
+      def items(value) = IO::BsonCodec.parse_array(value).fetch(:items)
+
+      def legacy_profile_documents
+        LEGACY_PROFILES.filter_map do |key, name|
+          value = @raw_document[key]
+          value.merge('Name' => value['Name'] || name) if value.is_a?(Hash)
+        end
+      end
+    end
+
+    # Typed view of one navigation profile, including recursive menu items.
+    class NavigationProfile
+      attr_reader :raw_document
+
+      def initialize(raw_document)
+        @raw_document = raw_document
+      end
+
+      def name = @raw_document['Name'].to_s
+      def kind = @raw_document['Kind'].to_s
+      def offline? = kind.match?(/offline/i)
+      def app_icon = @raw_document['AppIcon']
+      def app_title = text_translations(@raw_document['AppTitle'])
+      def home_page = reference(@raw_document.dig('HomePage', 'Page'))
+      def home_microflow = reference(@raw_document.dig('HomePage', 'Microflow'))
+      def sign_in_page = reference(@raw_document.dig('LoginPageSettings', 'Form'))
+
+      def role_homes
+        items(@raw_document['HomeItems'] || @raw_document['RoleBasedHomePages']).map do |home|
+          {
+            role: reference(home['UserRole']),
+            page: reference(home['Page']),
+            microflow: reference(home['Microflow'])
+          }.compact
+        end
+      end
+
+      def menu_items
+        collection = @raw_document['Menu'] || @raw_document['MenuItemCollection']
+        items(collection&.fetch('Items', nil)).map { navigation_item(_1) }
+      end
+
+      def to_h
+        base_profile.merge(
+          offline: offline?,
+          app_icon:,
+          app_title:,
+          items: menu_items
+        )
+      end
+
+      private
+
+      def base_profile
+        {
+          name:,
+          kind:,
+          home_page:,
+          home_microflow:,
+          sign_in_page:,
+          role_homes:
+        }
+      end
+
+      def items(value) = IO::BsonCodec.parse_array(value).fetch(:items)
+
+      def reference(value)
+        result = IO::BsonCodec.extract_id(value)
+        result.to_s.empty? ? nil : result
+      end
+
+      def text_translations(text)
+        return {} unless text.is_a?(Hash)
+
+        translations = items(text['Translations'] || text['Items']).to_h do |translation|
+          [translation['LanguageCode'].to_s, translation['Text'].to_s]
+        end
+        translations.reject { |_locale, value| value.empty? }
+      end
+
+      def navigation_item(item)
+        action = item['Action'].is_a?(Hash) ? item['Action'] : {}
+        {
+          caption: text_translations(item['Caption']),
+          page: reference(action.dig('FormSettings', 'Form')),
+          microflow: reference(action.dig('MicroflowSettings', 'Microflow')),
+          icon: item.dig('Icon', 'Code'),
+          items: items(item['Items']).map { navigation_item(_1) }
+        }.compact
+      end
+    end
+  end
+end