mxrb 0.1.0

data/lib/mxrb/compiler/security_materializer.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Mxrb
+  module Compiler
+    SecurityMaterialization = Data.define(:model_path, :metadata_path, :roles)
+
+    # Compiles project-security units into the flattened Runtime model shape.
+    class SecurityMaterializer
+      def initialize(mpr_path, deployment:)
+        @mpr_path = File.expand_path(mpr_path)
+        @deployment = File.expand_path(deployment)
+      end
+
+      def materialize
+        model_path = File.join(@deployment, 'model', 'model.mdp')
+        metadata_path = File.join(@deployment, 'model', 'metadata.json')
+        source = source_security
+        compiled, role_metadata = compile(source)
+        ModelPackage.read(model_path).upsert(compiled).write(model_path)
+        write_metadata(metadata_path, source, role_metadata)
+        SecurityMaterialization.new(model_path:, metadata_path:, roles: role_metadata.freeze)
+      end
+
+      private
+
+      def source_security
+        mpr = IO::MprFile.open(@mpr_path, readonly: true)
+        document = mpr.all_units.lazy.map { mpr.parse_contents(_1) }
+                      .find { _1['$Type'] == 'Security$ProjectSecurity' }
+        raise CompilationError, 'MPR has no project security document' unless document
+
+        document
+      ensure
+        mpr&.close
+      end
+
+      def compile(source)
+        source_roles = array(source['UserRoles'])
+        names = source_roles.map { _1['Name'].to_s }
+        roles = source_roles.map { compile_role(_1, names) }
+        [compiled_document(source, roles), role_metadata(source_roles, names)]
+      end
+
+      def compiled_document(source, roles)
+        {
+          '$ID' => source['$ID'], '$Type' => source['$Type'], 'UserRoles' => roles,
+          'DemoUsers' => array(source['DemoUsers']).map { compile_demo_user(_1) },
+          'PasswordPolicySettings' => source['PasswordPolicySettings'],
+          'SecurityLevel' => source['SecurityLevel'], 'AdminUserName' => source['AdminUserName'],
+          'AdminUserRole' => source['AdminUserRole'],
+          'EnableDemoUsers' => source['EnableDemoUsers'] == true,
+          'EnableGuestAccess' => source['EnableGuestAccess'] == true,
+          'GuestUserRole' => source['GuestUserRole'].to_s, 'StrictMode' => source['StrictMode'] == true
+        }
+      end
+
+      def compile_demo_user(user)
+        user.merge('UserRoles' => array(user['UserRoles']).map(&:to_s))
+      end
+
+      def compile_role(role, names)
+        manageable = role['ManageAllRoles'] == true ? names : array(role['ManageableRoles']).map(&:to_s)
+        {
+          '$ID' => role['$ID'], '$Type' => role['$Type'], 'GUID' => role['GUID'],
+          'Name' => role['Name'], 'Description' => role['Description'].to_s,
+          'IsSystemAdministrator' => array(role['ModuleRoles']).include?('System.Administrator'),
+          'ManageableRoles' => manageable,
+          'ManageUsersWithoutRoles' => role['ManageUsersWithoutRoles'] == true,
+          'CheckSecurity' => role['CheckSecurity'] != false
+        }
+      end
+
+      def role_metadata(roles, names)
+        ids = roles.to_h { [_1['Name'].to_s, id(_1['GUID'])] }
+        roles.to_h do |role|
+          [ids.fetch(role['Name'].to_s), metadata_role(role, names, ids)]
+        end
+      end
+
+      def metadata_role(role, names, ids)
+        manageable = role['ManageAllRoles'] == true ? names : array(role['ManageableRoles']).map(&:to_s)
+        resolved = manageable.filter_map { ids[_1] }
+        { 'Name' => role['Name'].to_s }.tap do |value|
+          value['ManageableRoles'] = resolved unless resolved.empty?
+        end
+      end
+
+      def write_metadata(path, source, roles)
+        metadata = JSON.parse(File.read(path))
+        metadata['Roles'] = roles
+        admin = roles.find { |_role_id, value| value['Name'] == source['AdminUserRole'] }
+        raise CompilationError, "admin role #{source['AdminUserRole'].inspect} is not defined" unless admin
+
+        metadata['AdminRole'] = admin.first
+        File.write(path, JSON.pretty_generate(metadata))
+      end
+
+      def array(value) = IO::BsonCodec.parse_array(value)[:items]
+      def id(value) = IO::BsonCodec.extract_id(value)
+    end
+  end
+end

data/lib/mxrb/compiler/settings_document_compiler.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    # Compiles project settings using the ordered, version-matched Runtime schema.
+    class SettingsDocumentCompiler
+      include ModelValues
+
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def compile(unit)
+        source = unit.document
+        unless source['$Type'] == 'Settings$ProjectSettings'
+          raise CompilationError,
+                "unsupported settings root #{source['$Type']}"
+        end
+
+        {
+          '$ID' => source['$ID'], '$Type' => source['$Type'],
+          'Settings' => array(source['Settings']).map { compile_node(_1) }
+        }
+      end
+
+      private
+
+      def compile_value(value)
+        case value
+        when Hash then value['$Type'] ? compile_node(value) : value.transform_values { compile_value(_1) }
+        when Array then array(value).map { compile_value(_1) }
+        else value
+        end
+      end
+
+      def compile_node(source)
+        existing = @schema.counterpart(source)
+        @schema.fields_for(source).to_h do |field|
+          value = source.key?(field) ? compile_value(source[field]) : existing&.fetch(field, nil)
+          [field, value]
+        end
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/settings_materializer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    SettingsMaterialization = Data.define(:model_path, :documents)
+
+    # Synchronizes Runtime-visible project settings, including lifecycle microflows.
+    class SettingsMaterializer
+      def initialize(mpr_path, deployment:)
+        @mpr_path = File.expand_path(mpr_path)
+        @deployment = File.expand_path(deployment)
+      end
+
+      def materialize
+        source = SourceModel.read(@mpr_path)
+        path = File.join(@deployment, 'model', 'model.mdp')
+        package = ModelPackage.read(path)
+        compiler = SettingsDocumentCompiler.new(RuntimeModelSchema.new(package, version: source.version))
+        documents = source.units_of('Settings$ProjectSettings').map { compiler.compile(_1) }
+        documents.reduce(package) { |result, document| result.upsert(document) }.write(path)
+        SettingsMaterialization.new(model_path: path, documents: documents.length)
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/source_model.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    # Read-only indexed view of MPR units used by native materializers.
+    class SourceModel
+      Unit = Data.define(:id, :container_id, :containment, :document, :module_name)
+      CLIENT_TYPE = /\A(?:Forms|JavaScriptActions|Menus|Navigation)\$|\AMicroflows\$Nanoflow\z/
+
+      attr_reader :path, :version, :units
+
+      def self.read(path) = new(File.expand_path(path))
+
+      def initialize(path)
+        @path = path
+        read_units
+      end
+
+      def documents(type = nil)
+        selected = type ? units.select { _1.document['$Type'] == type } : units
+        selected.map(&:document)
+      end
+
+      def units_of(type)
+        @units_by_type ||= units.group_by { _1.document['$Type'] }.transform_values(&:freeze).freeze
+        @units_by_type.fetch(type, EMPTY_UNITS)
+      end
+
+      def document_index
+        @document_index ||= {}.tap do |index|
+          units.each { index_document(_1.document, index) }
+        end.freeze
+      end
+
+      def web_page?(unit)
+        return false if unit.document['Excluded'] == true
+
+        layout_name = unit.document.dig('FormCall', 'Form').to_s
+        layout = units_of('Forms$Layout').find do |candidate|
+          "#{candidate.module_name}.#{candidate.document['Name']}" == layout_name
+        end
+        layout.nil? || layout.document.dig('Content', '$Type') != 'Forms$NativeLayoutContent'
+      end
+
+      def web_layout?(unit)
+        unit.document['Excluded'] != true &&
+          unit.document.dig('Content', '$Type') == 'Forms$WebLayoutContent'
+      end
+
+      def optimized_web_client?
+        settings = documents('Settings$ProjectSettings').first
+        web = nested_values(settings).find { _1.is_a?(Hash) && _1['$Type'] == 'Forms$WebUIProjectSettingsPart' }
+        web&.fetch('UseOptimizedClient', nil).to_s == 'Yes'
+      end
+
+      def client_reference?(qualified_name)
+        reference = /(?:\A|[^A-Za-z0-9_.])@#{Regexp.escape(qualified_name)}(?![A-Za-z0-9_.])/
+        units.any? do |unit|
+          unit.document['$Type'].to_s.match?(CLIENT_TYPE) && deep_string_match?(unit.document, reference)
+        end
+      end
+
+      private
+
+      EMPTY_UNITS = [].freeze
+
+      def read_units
+        mpr = IO::MprFile.open(path, readonly: true)
+        @version = mpr.mendix_version
+        raw_units = mpr.all_units
+        documents = raw_units.to_h { [_1['UnitID'], mpr.parse_contents(_1)] }
+        @units = build_units(raw_units, documents)
+      ensure
+        mpr&.close
+      end
+
+      def build_units(raw_units, documents)
+        raw_index = raw_units.to_h { [_1['UnitID'], _1] }
+        module_names = {}
+        raw_units.map do |raw|
+          Unit.new(
+            id: raw['UnitID'], container_id: raw['ContainerID'],
+            containment: raw['ContainmentName'], document: documents.fetch(raw['UnitID']),
+            module_name: resolve_module(raw, raw_index, documents, module_names)
+          )
+        end.freeze
+      end
+
+      def resolve_module(raw, raw_index, documents, cache)
+        id = raw['UnitID']
+        return cache[id] if cache.key?(id)
+
+        document = documents.fetch(id)
+        return cache[id] = document['Name'].to_s if document['$Type'] == 'Projects$ModuleImpl'
+        return cache[id] = nil if raw['ContainerID'] == id
+
+        parent = raw_index[raw['ContainerID']]
+        cache[id] = parent && resolve_module(parent, raw_index, documents, cache)
+      end
+
+      def deep_string_match?(value, pattern)
+        case value
+        when Hash then value.any? { |_key, child| deep_string_match?(child, pattern) }
+        when Array then value.any? { deep_string_match?(_1, pattern) }
+        else value.is_a?(String) && value.match?(pattern)
+        end
+      end
+
+      def nested_values(value)
+        case value
+        when Hash then [value, *value.values.flat_map { nested_values(_1) }]
+        when Array then value.flat_map { nested_values(_1) }
+        else []
+        end
+      end
+
+      def index_document(value, index)
+        case value
+        when Hash
+          id = IO::BsonCodec.extract_id(value['$ID'])
+          index[id] = value if id
+          value.each_value { index_document(_1, index) }
+        when Array then value.each { index_document(_1, index) }
+        end
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/system_model_seed.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'rubygems/version'
+require 'zlib'
+
+module Mxrb
+  module Compiler
+    # Versioned Runtime-owned System module omitted from application MPR files.
+    class SystemModelSeed
+      MODULE_ID = '6e3fe785-0e7d-42ec-a592-8bc1ea4ea87d'
+      VERSION_BANDS = [
+        ['6.0.0', '7.0.0', '6.10.8'],
+        ['7.0.0', '7.17.0', '7.5.0'],
+        ['7.17.0', '8.0.0', '7.17.0'],
+        ['9.0.0', '10.0.0', '9.6.1.29396'],
+        ['10.0.0', '11.0.0', '10.24.0.73019'],
+        ['11.0.0', '12.0.0', '11.12.1']
+      ].map { |minimum, maximum, seed| [Gem::Version.new(minimum), Gem::Version.new(maximum), seed] }
+       .freeze
+
+      def self.for(version)
+        seed_version = seed_version_for(version)
+        path = File.join(__dir__, 'schemas', "system-model-#{seed_version}.b64")
+        raise CompilationError, "no native System model seed for Mendix #{version}" unless File.file?(path)
+
+        bytes = Zlib.gunzip(Base64.decode64(File.read(path)))
+        new(ModelPackage.decode(bytes, File.basename(path)), target_version: version, seed_version:)
+      rescue Zlib::Error, ArgumentError => e
+        raise CompilationError, "invalid System model seed for Mendix #{version}: #{e.message}"
+      end
+
+      def self.seed_version_for(version) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        exact = version.to_s
+        return exact if File.file?(File.join(__dir__, 'schemas', "system-model-#{exact}.b64"))
+        unless exact.match?(/\A\d+(?:\.\d+){1,3}(?:[-+].*)?\z/)
+          raise CompilationError,
+                "invalid Mendix version #{version.inspect}"
+        end
+
+        target = Gem::Version.new(exact.scan(/\d+/).first(3).join('.'))
+        band = VERSION_BANDS.find { |minimum, maximum, _seed| target >= minimum && target < maximum }
+        return band.last if band
+
+        raise CompilationError,
+              "no audited native System model seed for Mendix #{version}; " \
+              'supported families are 6.x, 7.x, 9.x, 10.x, and 11.x'
+      rescue ArgumentError
+        raise CompilationError, "invalid Mendix version #{version.inspect}"
+      end # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      attr_reader :package, :target_version, :seed_version
+
+      def initialize(package, target_version: nil, seed_version: nil)
+        @package = package
+        @target_version = target_version&.to_s
+        @seed_version = seed_version&.to_s
+      end
+
+      def module_reference
+        module_document = package.find(MODULE_ID)&.document
+        domain = domain_document
+        validate_module!(module_document, domain)
+
+        {
+          '$ID' => module_document['$ID'], '$Type' => module_document['$Type'],
+          'DomainModel' => domain.slice('$ID', '$Type'),
+          'AllDocuments' => document_references(module_document, domain)
+        }
+      end
+
+      def domain_document
+        package.documents.find { _1['$Type'] == 'DomainModels$DomainModel' }
+      end
+
+      def document_references(module_document, domain)
+        documents = package.documents.reject { [module_document, domain].include?(_1) }
+        documents.map { _1.slice('$ID', '$Type') }
+      end
+
+      def validate_module!(module_document, domain)
+        return if module_document && domain
+
+        raise CompilationError, 'System model seed is missing its module or domain model'
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/system_queue_materializer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    SystemQueueMaterialization = Data.define(:model_path, :queues)
+
+    # Adds the Runtime's built-in System workflow queues absent from editor MPRs.
+    class SystemQueueMaterializer
+      QUEUES = [
+        %w[cc8b48dd-2c7e-4aa0-a614-3c683349cb72 MendixWorkflows-WorkflowExecution 5
+           3ba681ba-b94c-5f4a-82cb-d9e75947cb18],
+        %w[9d554d4e-7cf8-4a35-9504-a9f600f28e41 MendixWorkflows-DefaultTaskExecution 3
+           b06495bf-e4c6-5e62-8e98-56b7a852f440]
+      ].freeze
+
+      def initialize(mpr_path, deployment:)
+        @version = SourceModel.read(mpr_path).version
+        @deployment = File.expand_path(deployment)
+      end
+
+      def materialize # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        path = File.join(@deployment, 'model', 'model.mdp')
+        package = QUEUES.reduce(ModelPackage.read(path)) do |model, queue|
+          existing = model.documents.find { _1['QualifiedName'] == "System.#{queue[1]}" }
+          ids = if existing
+                  [existing['$ID'], existing.dig('Config', '$ID')]
+                else
+                  [queue[0], queue[3]]
+                end
+          model.upsert(document(ids[0], queue[1], queue[2], ids[1]))
+        end
+        package.write(path)
+        SystemQueueMaterialization.new(model_path: path, queues: QUEUES.length)
+      end # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      private
+
+      def document(id, name, parallelism, config_id)
+        {
+          '$ID' => id, '$Type' => 'Queues$Queue',
+          'Config' => queue_config(config_id, parallelism),
+          'Name' => name, 'QualifiedName' => "System.#{name}"
+        }
+      end
+
+      def queue_config(id, parallelism)
+        config = { '$ID' => id, '$Type' => 'Queues$BasicQueueConfig' }
+        return config.merge('Parallelism' => parallelism.to_i) if @version.to_i < 10
+
+        config.merge('ParallelismExpression' => parallelism, 'ClusterWide' => false)
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/system_text_materializer.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    SystemTextMaterialization = Data.define(:model_path, :texts)
+
+    # Stores the Runtime system-text index; localized values live in i18n properties.
+    class SystemTextMaterializer
+      include ModelValues
+
+      def initialize(mpr_path, deployment:)
+        @mpr_path = File.expand_path(mpr_path)
+        @deployment = File.expand_path(deployment)
+      end
+
+      def materialize
+        source = SourceModel.read(@mpr_path).units_of('Texts$SystemTextCollection').first
+        document = source ? compile(source.document) : empty_collection
+        path = File.join(@deployment, 'model', 'model.mdp')
+        ModelPackage.read(path).upsert(document).write(path)
+        SystemTextMaterialization.new(model_path: path, texts: document.fetch('SystemTexts').length)
+      end
+
+      private
+
+      def compile(source)
+        {
+          '$ID' => source['$ID'], '$Type' => source['$Type'],
+          'SystemTexts' => array(source['SystemTexts']).map { compile_text(_1) }
+        }
+      end
+
+      def empty_collection
+        {
+          '$ID' => '57d2ecb5-6c2f-4ffa-a0b3-a37a40da3adf',
+          '$Type' => 'Texts$SystemTextCollection', 'SystemTexts' => []
+        }
+      end
+
+      def compile_text(source)
+        {
+          '$ID' => source['$ID'], '$Type' => source['$Type'],
+          'Text' => source.fetch('Text').slice('$ID', '$Type'),
+          'InternalKey' => source['InternalKey']
+        }
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/translation_materializer.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Mxrb
+  module Compiler
+    TranslationMaterialization = Data.define(:directory, :languages, :strings, :files)
+
+    # Synchronizes all MPR Texts$Text values into Runtime Java-properties catalogs.
+    class TranslationMaterializer
+      include ModelValues
+
+      def initialize(mpr_path, deployment:)
+        @mpr_path = File.expand_path(mpr_path)
+        @deployment = File.expand_path(deployment)
+      end
+
+      def materialize
+        translations = collect(SourceModel.read(@mpr_path))
+        directory = File.join(@deployment, 'model', 'i18n')
+        FileUtils.mkdir_p(directory)
+        write_languages(directory, translations)
+        write_default(directory, translations)
+        result(directory, translations)
+      end
+
+      private
+
+      def collect(source)
+        result = Hash.new { |hash, language| hash[language] = {} }
+        source.documents.each { collect_value(_1, result) }
+        result
+      end
+
+      def collect_value(value, result)
+        case value
+        when Hash
+          collect_text(value, result) if value['$Type'] == 'Texts$Text'
+          value.each_value { collect_value(_1, result) }
+        when Array then array(value).each { collect_value(_1, result) }
+        end
+      end
+
+      def collect_text(text, result)
+        key = IO::BsonCodec.extract_id(text['$ID'])
+        return unless key
+
+        array(text['Items']).each do |translation|
+          language = translation['LanguageCode'].to_s
+          result[language][key] = translation['Text'].to_s unless language.empty?
+        end
+      end
+
+      def update(path, values)
+        lines = File.file?(path) ? File.readlines(path, chomp: true) : []
+        seen = {}
+        rendered = lines.map { replace_line(_1, values, seen) }
+        values.keys.sort.each { |key| rendered << property(key, values.fetch(key)) unless seen[key] }
+        File.write(path, "#{rendered.join("\n")}\n")
+      end
+
+      def replace_line(line, values, seen)
+        key = line[/\A([0-9a-f-]{36})=/i, 1]
+        return line unless key && values.key?(key)
+
+        seen[key] = true
+        property(key, values.fetch(key))
+      end
+
+      def property(key, value)
+        escaped = value.to_s.gsub('\\', '\\\\').gsub(/\r\n|\r|\n/, '\\n')
+                       .gsub(/([:=#!])/) { |character| "\\#{character}" }
+        "#{key}=#{escaped}"
+      end
+
+      def write_languages(directory, translations)
+        translations.each do |language, values|
+          update(File.join(directory, "translations_#{language}.properties"), values)
+        end
+      end
+
+      def write_default(directory, translations)
+        language = translations.key?('en_US') ? 'en_US' : translations.keys.min
+        update(File.join(directory, 'translations.properties'), translations.fetch(language, {}))
+      end
+
+      def result(directory, translations)
+        TranslationMaterialization.new(
+          directory:, languages: translations.keys.sort.freeze,
+          strings: translations.values.sum(&:length), files: translations.length + 1
+        )
+      end
+    end
+  end
+end