mxrb 0.1.0

data/lib/mxrb/compiler/microflow_document_compiler.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Mxrb
+  module Compiler
+    # Compiles microflow-family roots and delegates ordered graph nodes.
+    class MicroflowDocumentCompiler
+      include ModelValues
+      include RuntimeDataTypes
+
+      ROOT_TYPES = %w[Microflows$Microflow Microflows$Nanoflow Microflows$Rule].freeze
+
+      def initialize(source, schema)
+        @schema = schema
+        @nodes = MicroflowNodeCompiler.new(schema, source:)
+        @role_map = project_role_map(source)
+      end
+
+      def compile(unit)
+        source = unit.document
+        raise CompilationError, "unsupported flow root #{source['$Type']}" unless ROOT_TYPES.include?(source['$Type'])
+
+        @nodes.prepare(source)
+        @schema.fields_for(source).to_h do |field|
+          [field, root_value(source, field, unit.module_name)]
+        end
+      end
+
+      private
+
+      def root_value(source, field, module_name) # rubocop:disable Metrics/CyclomaticComplexity
+        case field
+        when '$ID', '$Type', 'Name' then source[field]
+        when 'ObjectCollection' then @nodes.compile(source['ObjectCollection'])
+        when 'SequenceFlows' then @nodes.compile(source['Flows'])
+        when 'QualifiedName' then "#{module_name}.#{source['Name']}"
+        when 'ReturnType' then data_type(source['MicroflowReturnType'])
+        when 'ModelerAllowedUserRoles' then allowed_user_roles(source)
+        when 'UrlSegments' then []
+        else generic_field(source, field)
+        end
+      end
+
+      def generic_field(source, field)
+        return @nodes.compile(source[field]) if source.key?(field)
+
+        existing = @schema.counterpart(source)
+        return existing[field] if existing&.key?(field)
+
+        root_default(source, field)
+      end
+
+      def root_default(source, field)
+        case field
+        when 'ConcurrenyErrorMessage'
+          { '$ID' => derived_id(source, field), '$Type' => 'Texts$Text' }
+        when 'ApplyEntityAccess', 'AllowConcurrentExecution' then false
+        when 'ConcurrencyErrorMicroflow', 'Url' then ''
+        when 'UrlSearchParameters' then []
+        else raise CompilationError, "cannot derive Runtime root field #{source['$Type']}.#{field}"
+        end
+      end
+
+      def allowed_user_roles(flow)
+        array(flow['AllowedModuleRoles']).flat_map { @role_map.fetch(_1.to_s, []) }.uniq
+      end
+
+      def project_role_map(source)
+        security = source.documents('Security$ProjectSecurity').first
+        return {} unless security
+
+        array(security['UserRoles']).each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |role, map|
+          array(role['ModuleRoles']).each { |module_role| map[module_role.to_s] << role['Name'].to_s }
+        end
+      end
+
+      def derived_id(source, label)
+        seed = "#{IO::BsonCodec.extract_id(source['$ID'])}:#{label}"
+        hex = Digest::SHA256.hexdigest(seed)[0, 32]
+        "#{hex[0, 8]}-#{hex[8, 4]}-4#{hex[13, 3]}-8#{hex[17, 3]}-#{hex[20, 12]}"
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/microflow_materializer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    MicroflowMaterialization = Data.define(:model_path, :microflows, :nanoflows, :rules)
+
+    # Materializes microflows, nanoflows, and rules using the version-matched Runtime schema.
+    class MicroflowMaterializer
+      TYPES = %w[Microflows$Microflow Microflows$Nanoflow Microflows$Rule].freeze
+
+      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)
+        Adapter.for(source.version)
+        path = File.join(@deployment, 'model', 'model.mdp')
+        package = ModelPackage.read(path)
+        documents = compile_documents(source, package)
+        write_model(path, package, documents)
+        result(path, documents)
+      end
+
+      private
+
+      def compile_documents(source, package)
+        compiler = MicroflowDocumentCompiler.new(
+          source, RuntimeModelSchema.new(package, version: source.version)
+        )
+        source.units.select { TYPES.include?(_1.document['$Type']) }.map { compiler.compile(_1) }
+      end
+
+      def write_model(path, package, documents)
+        documents.reduce(package) { |result, document| result.upsert(document) }.write(path)
+      end
+
+      def result(path, documents)
+        counts = documents.map { _1['$Type'] }.tally
+        MicroflowMaterialization.new(
+          model_path: path, microflows: counts.fetch('Microflows$Microflow', 0),
+          nanoflows: counts.fetch('Microflows$Nanoflow', 0), rules: counts.fetch('Microflows$Rule', 0)
+        )
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/microflow_node_compiler.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Mxrb
+  module Compiler
+    # rubocop:disable Metrics/AbcSize, Metrics/ClassLength, Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
+    # Recursively compiles ordered objects nested inside microflow graphs.
+    class MicroflowNodeCompiler
+      include ModelValues
+      include RuntimeDataTypes
+
+      FIELD_SOURCES = {
+        ['Microflows$BasicCodeActionParameterValue', 'ValueExpression'] => 'Argument',
+        ['Microflows$CreateVariableAction', 'Type'] => 'VariableType',
+        ['Microflows$MicroflowParameter', 'Type'] => 'VariableType',
+        ['Microflows$MappingRequestHandling', 'ContentTypeRuntime'] => 'ContentType',
+        ['Microflows$RetrieveSorting', 'AttributePath'] => 'AttributeRef',
+        ['Microflows$RestCallAction', 'RequestTimeOutExpression'] => 'TimeOutExpression',
+        ['Microflows$ResultHandling', 'VariableDataType'] => 'VariableType'
+      }.freeze
+      TYPE_DEFAULTS = {
+        'Microflows$NoCase' => { 'StringRepresentation' => '' }
+      }.freeze
+      RUNTIME_DERIVED_FIELDS = {
+        'Microflows$ActionActivity' => %w[Caption]
+      }.freeze
+      EDITORIAL_TYPES = %w[Microflows$AnnotationFlow].freeze
+
+      def initialize(schema, source: nil)
+        @schema = schema
+        @database_connector = DatabaseConnectorActionCompiler.new(source) if source.respond_to?(:units)
+        @associations = association_index(source)
+        @variable_types = {}
+      end
+
+      def prepare(flow)
+        @variable_types = {}
+        visit(flow) do |node|
+          next unless node['$Type'] == 'Microflows$MicroflowParameter'
+
+          entity = node.dig('VariableType', 'Entity').to_s
+          @variable_types[node['Name'].to_s] = entity unless entity.empty?
+        end
+      end
+
+      def compile(value)
+        case value
+        when Hash then compile_hash(value)
+        when Array then array(value).filter_map { compile(_1) }
+        else value
+        end
+      end
+
+      private
+
+      def compile_hash(value)
+        return value.to_h { |key, child| [key, compile(child)] } unless value['$Type']
+        return nil if EDITORIAL_TYPES.include?(value['$Type'])
+        return compile_custom_range(value) if value['$Type'] == 'Microflows$CustomRange'
+
+        if value['$Type'] == 'DatabaseConnector$ExecuteDatabaseQueryAction'
+          return compile(noop_database_action(value)) if @database_connector.unconfigured_write?(value)
+
+          return compile(@database_connector.compile(value))
+        end
+
+        compile_node(value)
+      end
+
+      def compile_custom_range(source)
+        {
+          '$ID' => derived_id(source, 'constant-range'), '$Type' => 'Microflows$ConstantRange',
+          'SingleObject' => source['SingleObject'] == true
+        }
+      end
+
+      def noop_database_action(source)
+        {
+          '$ID' => source['$ID'], '$Type' => 'Microflows$LogMessageAction',
+          'MessageTemplate' => {
+            '$ID' => derived_id(source, 'local-fallback-message'),
+            '$Type' => 'Microflows$StringTemplate', 'Parameters' => [], 'Text' => ''
+          },
+          'ErrorHandlingType' => source.fetch('ErrorHandlingType', 'Rollback'),
+          'Level' => 'Trace', 'Node' => "'Mxrb'", 'IncludeLatestStackTrace' => false
+        }
+      end
+
+      def compile_node(source)
+        @schema.fields_for(source).to_h { |field| [field, node_value(source, field)] }
+      end
+
+      def node_value(source, field)
+        return source[field] if %w[$ID $Type].include?(field)
+        if field == 'Type' && %w[
+          Microflows$AssociationRetrieveSource Microflows$DatabaseRetrieveSource
+        ].include?(source['$Type'])
+          return retrieve_type(source)
+        end
+        if field == 'StringRepresentation' && source['$Type'] == 'Microflows$InheritanceCase'
+          return derived_default(source, field)
+        end
+        if field == 'ValueExpression' && source['$Type'] == 'Microflows$MicroflowParameterValue'
+          return "'#{source.fetch('Microflow')}'"
+        end
+
+        existing = @schema.counterpart(source)
+        if RUNTIME_DERIVED_FIELDS.fetch(source['$Type'], []).include?(field) && existing&.key?(field)
+          return existing[field]
+        end
+
+        source_field = if source.key?(field)
+                         field
+                       else
+                         FIELD_SOURCES.fetch([source['$Type'], field], field)
+                       end
+        return converted_field(source, source_field, field) if source.key?(source_field)
+
+        default_or_existing(source, field)
+      end
+
+      def converted_field(source, source_field, runtime_field)
+        value = source[source_field]
+        return runtime_attribute_path(value) if runtime_field == 'AttributePath'
+        return data_type(value) if %w[Type VariableDataType].include?(runtime_field) && data_type_document?(value)
+
+        compile(value)
+      end
+
+      def runtime_attribute_path(reference)
+        attribute = if reference.is_a?(Hash)
+                      reference.fetch('Attribute', '').to_s
+                    else
+                      reference.to_s
+                    end
+        entity = attribute.rpartition('.').first
+        entity.empty? ? attribute : "#{entity}/#{attribute}"
+      end
+
+      def default_or_existing(source, field)
+        defaults = TYPE_DEFAULTS.fetch(source['$Type'], {})
+        return defaults[field] if defaults.key?(field)
+
+        existing = @schema.counterpart(source)
+        return existing[field] if existing&.key?(field)
+
+        derived_default(source, field)
+      end
+
+      def derived_default(source, field)
+        case field
+        when 'Argument' then source.dig('Value', 'Argument').to_s
+        when 'QueueSettings', 'NewCaseValue' then nil
+        when 'Location' then 'Content'
+        when 'ParameterMappings' then []
+        when 'StringRepresentation'
+          return '(empty)' if source['$Type'] == 'Microflows$InheritanceCase' && source['Value'].to_s.empty?
+
+          source['Value'].to_s
+        when 'Type' then derived_runtime_type(source)
+        when 'IsRequired', 'Disabled' then source.fetch(field, false) == true
+        when 'DefaultValue', 'Caption', 'ResultVariableName', 'OutputVariableName',
+             'FormObjectVariable', 'Queue' then ''
+        else raise CompilationError, "cannot derive Runtime field #{source['$Type']}.#{field}"
+        end
+      end
+
+      def derived_runtime_type(source)
+        if source['$Type'] == 'Microflows$AggregateAction'
+          return 'Integer' if source['AggregateFunction'] == 'Count'
+
+          raise CompilationError,
+                "cannot derive #{source['AggregateFunction']} aggregate type without an audited attribute type"
+        end
+
+        retrieve_type(source)
+      end
+
+      def retrieve_type(source)
+        return association_retrieve_type(source) if source['$Type'] == 'Microflows$AssociationRetrieveSource'
+        unless source['$Type'] == 'Microflows$DatabaseRetrieveSource'
+          raise CompilationError, "cannot derive Runtime retrieve type for #{source['$Type']}"
+        end
+
+        single = source.dig('Range', 'SingleObject') == true
+        single ? source['Entity'].to_s : "[#{source['Entity']}]"
+      end
+
+      def association_retrieve_type(source)
+        association = @associations[source['AssociationId'].to_s] || runtime_association(source['AssociationId'].to_s)
+        raise CompilationError, "unknown association #{source['AssociationId'].inspect}" unless association
+
+        start = @variable_types[source['StartVariableName'].to_s]
+        target = start == association[:child] ? association[:parent] : association[:child]
+        return if target.to_s.empty?
+
+        list = association[:reference_set] || start == association[:child]
+        list ? "[#{target}]" : target
+      end
+
+      def runtime_association(name)
+        association = @schema.respond_to?(:named) && @schema.named(name)
+        return unless association
+
+        parent = @schema.counterpart_id(association['ParentPointer'])
+        child = @schema.counterpart_id(association['ChildPointer'])
+        {
+          parent: parent&.fetch('QualifiedName', nil), child: child&.fetch('QualifiedName', nil),
+          reference_set: association['Type'] == 'ReferenceSet'
+        }
+      end
+
+      def association_index(source)
+        return {} unless source.respond_to?(:units_of)
+
+        source.units_of('DomainModels$DomainModel').each_with_object({}) do |unit, result|
+          entities = array(unit.document['Entities']).to_h do |entity|
+            [IO::BsonCodec.extract_id(entity['$ID']), "#{unit.module_name}.#{entity['Name']}"]
+          end
+          array(unit.document['Associations']).each do |association|
+            result["#{unit.module_name}.#{association['Name']}"] = {
+              parent: entities[IO::BsonCodec.extract_id(association['ParentPointer'])],
+              child: entities[IO::BsonCodec.extract_id(association['ChildPointer'])],
+              reference_set: association['Type'] == 'ReferenceSet'
+            }
+          end
+        end
+      end
+
+      def visit(value, &block)
+        case value
+        when Hash
+          block.call(value) if value['$Type']
+          value.each_value { visit(_1, &block) }
+        when Array then value.each { visit(_1, &block) }
+        end
+      end
+
+      def derived_id(source, label)
+        seed = "#{IO::BsonCodec.extract_id(source['$ID'])}:#{label}"
+        hex = Digest::SHA256.hexdigest(seed)[0, 32]
+        "#{hex[0, 8]}-#{hex[8, 4]}-4#{hex[13, 3]}-8#{hex[17, 3]}-#{hex[20, 12]}"
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/ClassLength, Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
+  end
+end

data/lib/mxrb/compiler/model_package.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tmpdir'
+
+module Mxrb
+  module Compiler
+    # Mendix model.mdp is an ordered stream of BSON documents without a
+    # container header. Each document carries its own int32 BSON length.
+    class ModelPackage
+      Entry = Data.define(:offset, :size, :document) do
+        def id = IO::BsonCodec.extract_id(document['$ID'])
+        def type = document['$Type'].to_s
+      end
+
+      attr_reader :entries
+
+      def self.read(path)
+        bytes = File.binread(path)
+        new(parse(bytes, path))
+      end
+
+      def self.empty = new([].freeze)
+      def self.decode(bytes, label = 'model.mdp') = new(parse(bytes, label))
+
+      def self.from_documents(documents)
+        new([].freeze).then do |package|
+          documents.reduce(package) { |result, document| result.with_appended(document) }
+        end
+      end
+
+      def self.parse(bytes, label = 'model.mdp')
+        entries = []
+        offset = 0
+        while offset < bytes.bytesize
+          entry = parse_entry(bytes, offset, label)
+          entries << entry
+          offset += entry.size
+        end
+        entries.freeze
+      rescue SerializationError => e
+        raise CompilationError, "#{label}: #{e.message}"
+      end
+      private_class_method :parse
+
+      def self.parse_entry(bytes, offset, label)
+        size = document_size(bytes, offset, label)
+        document = IO::BsonCodec.parse(bytes.byteslice(offset, size))
+        Entry.new(offset:, size:, document:)
+      end
+      private_class_method :parse_entry
+
+      def self.document_size(bytes, offset, label)
+        remaining = bytes.bytesize - offset
+        raise CompilationError, "#{label}: truncated BSON length at byte #{offset}" if remaining < 4
+
+        size = bytes.byteslice(offset, 4).unpack1('l<')
+        return size if size.between?(5, remaining)
+
+        raise CompilationError, "#{label}: invalid BSON size #{size} at byte #{offset}"
+      end
+      private_class_method :document_size
+
+      def initialize(entries)
+        @entries = entries
+      end
+
+      def documents = entries.map(&:document)
+      def types = entries.map(&:type).tally.freeze
+      def find(id) = entries.find { _1.id == id }
+
+      def replace(id, document)
+        index = entries.index { _1.id == id }
+        raise CompilationError, "model document #{id} not found" unless index
+
+        updated = entries.map.with_index do |entry, position|
+          position == index ? Entry.new(offset: 0, size: 0, document:) : entry
+        end
+        self.class.new(reindex(updated))
+      end
+
+      def upsert(document)
+        id = IO::BsonCodec.extract_id(document['$ID'])
+        raise CompilationError, 'model document has no $ID' unless id
+        return replace(id, document) if find(id)
+
+        self.class.new(reindex(entries + [Entry.new(offset: 0, size: 0, document:)]))
+      end
+
+      def with_appended(document)
+        self.class.new(reindex(entries + [Entry.new(offset: 0, size: 0, document:)]))
+      end
+
+      def write(path)
+        output = File.expand_path(path)
+        FileUtils.mkdir_p(File.dirname(output))
+        Dir.mktmpdir('mxrb-model-', File.dirname(output)) do |directory|
+          temporary = File.join(directory, 'model.mdp')
+          File.binwrite(temporary, entries.map { IO::BsonCodec.serialize(_1.document) }.join)
+          FileUtils.mv(temporary, output, force: true)
+        end
+        output
+      end
+
+      private
+
+      def reindex(source)
+        offset = 0
+        source.map do |entry|
+          size = IO::BsonCodec.serialize(entry.document).bytesize
+          Entry.new(offset:, size:, document: entry.document).tap { offset += size }
+        end.freeze
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/model_values.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    # Normalizes MPR's BSON array convention into Runtime-native values.
+    module ModelValues
+      private
+
+      def array(value) = IO::BsonCodec.parse_array(value)[:items]
+      def plain_array(value) = value ? array(value).map { plain_value(_1) } : []
+      def plain_document(value) = value ? plain_value(value) : nil
+
+      def xpath_variables(constraint)
+        constraint.to_s.scan(/\$([A-Za-z_]\w*)/).flatten.uniq
+      end
+
+      def object_page_parameters(document, names)
+        indexed = page_parameter_types(document)
+        entities = names.to_h { |name| [name, object_parameter_entity(indexed[name])] }
+        entities if entities.values.all?
+      end
+
+      def page_parameter_types(document)
+        array(document&.fetch('Parameters', nil)).filter_map do |parameter|
+          next unless parameter.is_a?(Hash)
+
+          [parameter['Name'].to_s, parameter['ParameterType'] || {}]
+        end.to_h
+      end
+
+      def object_parameter_entity(type)
+        return unless type&.fetch('$Type', nil) == 'DataTypes$ObjectType'
+
+        entity = type['Entity'].to_s
+        entity unless entity.empty?
+      end
+
+      def image_bytes(value)
+        value.respond_to?(:data) ? value.data : value.to_s.b
+      end
+
+      def image_format(source) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        explicit = source['ImageFormat'].to_s.downcase
+        return explicit unless explicit.empty?
+
+        bytes = image_bytes(source['Image'])
+        return 'png' if bytes.start_with?("\x89PNG\r\n\x1A\n".b)
+        return 'gif' if bytes.start_with?('GIF87a', 'GIF89a')
+        return 'jpg' if bytes.start_with?("\xFF\xD8\xFF".b)
+        return 'bmp' if bytes.start_with?('BM')
+        return 'ico' if bytes.start_with?("\x00\x00\x01\x00".b)
+        return 'webp' if bytes.start_with?('RIFF') && bytes.byteslice(8, 4) == 'WEBP'
+        return 'svg' if bytes.byteslice(0, 1024).to_s.match?(/<svg\b/i)
+
+        raise CompilationError, "cannot determine format for image #{source['Name'].inspect}"
+      end # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+      def plain_value(value)
+        case value
+        when Hash then value.to_h { |key, child| [key, plain_value(child)] }
+        when Array then array(value).map { plain_value(_1) }
+        else value
+        end
+      end
+    end
+  end
+end