mxrb 0.1.0

data/lib/mxrb/runtime/native.rb

@@ -0,0 +1,474 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Mxrb
+  module Runtime
+    module Native
+      # Graph interpretation intentionally keeps semantic dispatch together.
+      # rubocop:disable Metrics/AbcSize, Metrics/ClassLength, Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
+      ObjectValue = Data.define(:entity, :id, :members)
+
+      # Transactional in-memory persistence used by the Ruby model Runtime.
+      class Store
+        def initialize
+          @records = Hash.new { |records, entity| records[entity] = [] }
+        end
+
+        def create(entity)
+          ObjectValue.new(entity:, id: SecureRandom.uuid, members: {}).tap do |object|
+            @records[entity] << object
+          end
+        end
+
+        def retrieve(entity) = @records[entity].dup
+
+        def delete(value)
+          Array(value).each { @records[_1.entity].delete(_1) }
+        end
+
+        def count(entity, predicate = nil)
+          values = retrieve(entity)
+          predicate ? values.count { predicate.call(_1) } : values.size
+        end
+
+        def snapshot
+          @records.to_h do |entity, values|
+            [entity, values.map { ObjectValue.new(entity: _1.entity, id: _1.id, members: _1.members.dup) }]
+          end
+        end
+
+        def restore(snapshot)
+          @records.clear
+          snapshot.each { |entity, values| @records[entity] = values }
+        end
+      end
+
+      # Deliberately small Mendix-expression evaluator. Unsupported syntax is
+      # rejected rather than guessed, preserving deterministic test semantics.
+      class Expression
+        COMPARISONS = {
+          '=' => ->(left, right) { left == right },
+          '!=' => ->(left, right) { left != right },
+          '>' => ->(left, right) { left > right },
+          '<' => ->(left, right) { left < right },
+          '>=' => ->(left, right) { left >= right },
+          '<=' => ->(left, right) { left <= right }
+        }.freeze
+
+        def evaluate(source, variables, node: nil)
+          text = strip_outer_parentheses(unwrap(source).strip)
+          return nil if text.empty? || text == 'empty'
+          return true if text.casecmp?('true')
+          return false if text.casecmp?('false')
+          return text[1...-1].gsub("''", "'") if quoted?(text)
+          return Integer(text) if text.match?(/\A-?\d+\z/)
+          return Float(text) if text.match?(/\A-?\d+\.\d+\z/)
+          return variable(text, variables) if text.match?(%r{\A\$[A-Za-z_]\w*(?:/[A-Za-z_][\w.]*)?\z})
+          return node_member(text, node) if node && bare_reference?(text)
+
+          logical(text, variables) { |part| evaluate(part, variables, node:) }
+        rescue ArgumentError, TypeError
+          raise NativeRuntimeError, "unsupported Mendix expression: #{source.inspect}"
+        end
+
+        private
+
+        def unwrap(source)
+          source.is_a?(Hash) ? (source['Value'] || source['Expression'] || '') : source.to_s
+        end
+
+        def quoted?(text)
+          text.length >= 2 && text.start_with?("'") && text.end_with?("'")
+        end
+
+        def strip_outer_parentheses(text)
+          text = text[1...-1].strip while text.start_with?('(') && matching_parenthesis(text, 0) == text.length - 1
+          text
+        end
+
+        def matching_parenthesis(text, opening)
+          depth = 0
+          quoted = false
+          text.each_char.with_index do |character, index|
+            next if index < opening
+
+            quoted = !quoted if character == "'"
+            next if quoted
+
+            depth += 1 if character == '('
+            depth -= 1 if character == ')'
+            return index if depth.zero?
+          end
+          nil
+        end
+
+        def variable(text, variables)
+          name, member = text.delete_prefix('$').split('/', 2)
+          value = variables.fetch(name) do
+            raise NativeRuntimeError, "unknown variable $#{name}"
+          end
+          return value unless member
+
+          raise NativeRuntimeError, "$#{name} is not an object" unless value.is_a?(ObjectValue)
+
+          value.members[member.split('.').last]
+        end
+
+        # An attribute reference inside an XPath predicate, e.g. `Name` or
+        # `Clinic.Animal/Name`, resolved against the current candidate object.
+        def bare_reference?(text)
+          text.match?(%r{\A[A-Za-z_]\w*(?:/[A-Za-z_][\w.]*)?\z})
+        end
+
+        def node_member(text, node)
+          node.members[text.split('/').last.split('.').last]
+        end
+
+        def logical(text, variables, &block)
+          split = split_operator(text, /\s+or\s+/i)
+          return split.any? { yield(_1) } if split.size > 1
+
+          split = split_operator(text, /\s+and\s+/i)
+          return split.all? { yield(_1) } if split.size > 1
+
+          comparison(text, variables, &block)
+        end
+
+        def comparison(text, _variables)
+          match = text.match(/\A\(?(.+?)\)?\s*(=|!=|>=|<=|>|<)\s*\(?(.+?)\)?\z/)
+          raise ArgumentError unless match
+
+          left = yield(match[1])
+          right = yield(match[3])
+          COMPARISONS.fetch(match[2]).call(left, right)
+        end
+
+        def split_operator(text, operator)
+          text.split(operator)
+        end
+      end
+
+      # Executes the graph and core data activities directly from the MPR.
+      class Interpreter
+        attr_reader :store, :log
+
+        def initialize(project, store: Store.new)
+          @project = project
+          @store = store
+          @expression = Expression.new
+          @log = []
+          @flows = project.modules.flat_map do |mod|
+            mod.microflows.map { ["#{mod.name}.#{_1.name}", _1] }
+          end.to_h
+        end
+
+        def call(name, arguments = {})
+          flow = @flows[name]
+          raise NativeRuntimeError, "microflow #{name} not found" unless flow
+
+          snapshot = store.snapshot
+          execute(flow, normalize_arguments(flow, arguments))
+        rescue StandardError
+          store.restore(snapshot) if snapshot
+          raise
+        end
+
+        # Counts stored objects of an entity, optionally narrowed by an XPath
+        # constraint. Used by the functional Executor's count expectations.
+        def count(entity, xpath = nil)
+          filter_by_xpath(store.retrieve(entity.to_s), xpath.to_s, {}).size
+        end
+
+        private
+
+        def execute(flow, variables)
+          objects = flow.objects.to_h { [identifier(_1), _1] }
+          outgoing = flow.flows.reject { _1['IsErrorHandler'] == true }
+                         .group_by { identifier(_1['OriginPointer']) }
+          current = flow.objects.find { _1['$Type'] == 'Microflows$StartEvent' }
+          raise NativeRuntimeError, "microflow #{flow.name} has no start event" unless current
+
+          10_000.times do
+            type = current['$Type']
+            return @expression.evaluate(current['ReturnValue'], variables) if type == 'Microflows$EndEvent'
+
+            execute_action(current['Action'], variables) if type == 'Microflows$ActionActivity'
+            edge = select_edge(current, outgoing[identifier(current)] || [], variables)
+            raise NativeRuntimeError, "microflow #{flow.name} stops at #{type}" unless edge
+
+            current = objects[identifier(edge['DestinationPointer'])]
+            raise NativeRuntimeError, 'sequence flow points to a missing object' unless current
+          end
+          raise NativeRuntimeError, "microflow #{flow.name} exceeded 10000 steps"
+        end
+
+        def select_edge(object, edges, variables)
+          return edges.first unless %w[Microflows$ExclusiveSplit Microflows$InheritanceSplit].include?(object['$Type'])
+
+          value = split_value(object, variables)
+          edges.find { flow_case(_1) == value.to_s } || edges.find { flow_case(_1).empty? }
+        end
+
+        def split_value(object, variables)
+          if object['$Type'] == 'Microflows$InheritanceSplit'
+            value = variables.fetch(object['SplitVariableName'].to_s)
+            value.respond_to?(:entity) ? value.entity : value.class.name
+          else
+            @expression.evaluate(object.dig('SplitCondition', 'Expression'), variables)
+          end
+        end
+
+        def flow_case(edge)
+          values = items(edge['CaseValues'])
+          value = values.first || edge['NewCaseValue'] || {}
+          value['$Type'] == 'Microflows$NoCase' ? '' : value['Value'].to_s
+        end
+
+        def execute_action(action, variables)
+          raise NativeRuntimeError, 'action activity has no action' unless action.is_a?(Hash)
+
+          handler = action['$Type'].to_s.delete_prefix('Microflows$').delete_suffix('Action')
+          method = "action_#{underscore(handler)}"
+          raise NativeRuntimeError, "unsupported activity #{action['$Type']}" unless respond_to?(method, true)
+
+          send(method, action, variables)
+        end
+
+        def action_create_change(action, variables)
+          object = store.create(action['Entity'].to_s)
+          apply_changes(object, action['Items'], variables)
+          variables[action['VariableName'].to_s] = object
+        end
+
+        def action_change(action, variables)
+          object = variables.fetch(action['ChangeVariableName'].to_s)
+          apply_changes(object, action['Items'], variables)
+        end
+
+        def action_create_variable(action, variables)
+          variables[action['VariableName'].to_s] = @expression.evaluate(action['InitialValue'], variables)
+        end
+
+        def action_change_variable(action, variables)
+          variables[action['ChangeVariableName'].to_s] = @expression.evaluate(action['Value'], variables)
+        end
+
+        def action_retrieve(action, variables)
+          source = action['RetrieveSource'] || {}
+          unless source['$Type'] == 'Microflows$DatabaseRetrieveSource'
+            raise NativeRuntimeError, "unsupported retrieve source #{source['$Type']}"
+          end
+
+          values = filter_by_xpath(store.retrieve(source['Entity'].to_s), source['XpathConstraint'].to_s, variables)
+          values = sort_values(values, items(source.dig('NewSortings', 'Sortings')))
+          range = source['Range'] || {}
+          limit = @expression.evaluate(range['LimitExpression'], variables)
+          values = values.first(limit) if limit.is_a?(Integer) && limit.positive?
+          variables[action['ResultVariableName'].to_s] = range['SingleObject'] == true ? values.first : values
+        end
+
+        # Narrows a value set by a Mendix XPath constraint. Only attribute
+        # predicates (comparisons, and/or, boolean shorthand) are understood;
+        # anything else is rejected by the expression evaluator rather than
+        # silently ignored.
+        def filter_by_xpath(values, xpath, variables)
+          predicate = xpath_predicate(xpath)
+          return values if predicate.empty?
+
+          values.select { @expression.evaluate(predicate, variables, node: _1) }
+        end
+
+        def xpath_predicate(xpath)
+          text = xpath.strip
+          return '' if text.empty?
+
+          groups = text.scan(/\[([^\[\]]*)\]/).flatten.map(&:strip).reject(&:empty?)
+          unless groups.any? && text.gsub(/\[[^\[\]]*\]/, '').strip.empty?
+            raise NativeRuntimeError, "unsupported native XPath constraint: #{xpath.inspect}"
+          end
+
+          groups.map { "(#{_1})" }.join(' and ')
+        end
+
+        def sort_values(values, sortings)
+          return values if sortings.empty?
+
+          keys = sortings.map { [sort_attribute(_1), descending?(_1)] }
+          values.sort { |left, right| compare_by_keys(left, right, keys) }
+        end
+
+        def compare_by_keys(left, right, keys)
+          keys.each do |attribute, descending|
+            comparison = compare_members(left.members[attribute], right.members[attribute])
+            comparison = -comparison if descending
+            return comparison unless comparison.zero?
+          end
+          0
+        end
+
+        def compare_members(left, right)
+          return 0 if left.nil? && right.nil?
+          return 1 if left.nil?
+          return -1 if right.nil?
+
+          (left <=> right) || raise(NativeRuntimeError, "cannot sort #{left.inspect} and #{right.inspect}")
+        end
+
+        def sort_attribute(sorting)
+          path = (sorting['AttributePath'] || sorting.dig('AttributeRef', 'Attribute')).to_s
+          raise NativeRuntimeError, 'native retrieve sorting requires an attribute' if path.empty?
+
+          path.split(%r{[./]}).last
+        end
+
+        def descending?(sorting)
+          sorting['SortOrder'].to_s.casecmp?('Descending')
+        end
+
+        def action_aggregate(action, variables)
+          values = Array(variables.fetch(action['AggregateVariableName'].to_s))
+          attribute = action['Attribute'].to_s.split('.').last.to_s
+          members = attribute.empty? ? values : values.map { _1.members[attribute] }
+          result = aggregate(action['AggregateFunction'], members)
+          variables[action['VariableName'].to_s] = result
+        end
+
+        def action_microflow_call(action, variables)
+          call_doc = action['MicroflowCall'] || {}
+          arguments = items(call_doc['ParameterMappings']).to_h do |mapping|
+            [mapping['Parameter'].to_s.split('.').last, @expression.evaluate(mapping['Argument'], variables)]
+          end
+          result = call(call_doc['Microflow'].to_s, arguments)
+          variables[action['ResultVariableName'].to_s] = result if action['UseReturnVariable'] == true
+        end
+
+        def action_commit(_action, _variables); end
+
+        def action_delete(action, variables)
+          store.delete(variables.fetch(action['DeleteVariableName'].to_s))
+        end
+
+        def action_log_message(action, variables)
+          @log << render_template(action['MessageTemplate'], variables)
+        end
+
+        def action_cast(_action, _variables); end
+
+        def aggregate(function, values)
+          case function.to_s.downcase
+          when 'count' then values.size
+          when 'sum' then values.compact.sum
+          when 'minimum', 'min' then values.compact.min
+          when 'maximum', 'max' then values.compact.max
+          when 'average', 'avg' then values.empty? ? nil : values.compact.sum.to_f / values.compact.size
+          else raise NativeRuntimeError, "unsupported aggregate #{function}"
+          end
+        end
+
+        def apply_changes(object, values, variables)
+          items(values).each do |item|
+            member = (item['Attribute'].to_s.empty? ? item['Association'] : item['Attribute']).to_s
+            name = member.split(%r{[./]}).last
+            object.members[name] = @expression.evaluate(item['Value'], variables)
+          end
+        end
+
+        def render_template(template, variables)
+          text = template&.dig('Text').to_s
+          items(template&.dig('Parameters')).each_with_index do |parameter, index|
+            text = text.gsub("{#{index + 1}}", @expression.evaluate(parameter['Expression'], variables).to_s)
+          end
+          text
+        end
+
+        def normalize_arguments(flow, arguments)
+          names = flow.parameters.filter_map { _1['Name'] if _1.is_a?(Hash) }
+          names.to_h do |name|
+            [name, arguments.fetch(name) { raise NativeRuntimeError, "missing argument #{name}" }]
+          end
+        end
+
+        def items(value)
+          IO::BsonCodec.parse_array(value)[:items]
+        rescue StandardError
+          Array(value).drop(value.is_a?(Array) && value.first.is_a?(Integer) ? 1 : 0)
+        end
+
+        def identifier(value)
+          IO::BsonCodec.extract_id(value.is_a?(Hash) ? value['$ID'] : value).to_s
+        end
+
+        def underscore(value)
+          value.gsub(/([a-z\d])([A-Z])/, '\\1_\\2').downcase
+        end
+      end
+
+      # Runs existing functional definitions against the Ruby interpreter.
+      class Executor
+        def initialize(project_path, definition, output: nil, clock: Process.method(:clock_gettime), **)
+          @project_path = File.expand_path(project_path)
+          @definition = definition
+          @output = output
+          @clock = clock
+        end
+
+        def run
+          started = monotonic_time
+          project = Model::Project.open(@project_path)
+          interpreter = Interpreter.new(project)
+          tests = @definition.tests.map { run_test(interpreter, _1) }
+          transcript = tests.map { "[MXRB_TEST] #{_1.passed? ? 'PASS' : 'FAIL'} #{_1.name}" }.join("\n")
+          transcript = "#{transcript}\n[MXRB_TEST] DONE\n"
+          @output&.write(transcript)
+          Execution.new(
+            Functional::Result.new(tests.freeze, true), 'MXRB native validation passed',
+            'Ruby microflow interpreter', transcript, monotonic_time - started
+          )
+        ensure
+          project&.close
+        end
+
+        private
+
+        def run_test(interpreter, test)
+          interpreter.call(test.setup.target, evaluated_arguments(test.setup.arguments)) if test.setup
+          actual = interpreter.call(test.target, evaluated_arguments(test.arguments))
+          failures = expectations(interpreter, test, actual)
+          interpreter.call(test.cleanup.target, evaluated_arguments(test.cleanup.arguments)) if test.cleanup
+          Functional::TestResult.new(test.name, failures.empty?, failures.empty? ? 'passed' : failures.join('; '))
+        rescue StandardError => e
+          Functional::TestResult.new(test.name, false, e.message)
+        end
+
+        def expectations(interpreter, test, actual)
+          failures = []
+          if test.expected_return
+            expected = Expression.new.evaluate(test.expected_return, {})
+            failures << "return #{actual.inspect}, expected #{expected.inspect}" unless actual == expected
+          end
+          test.counts.each do |expectation|
+            actual_count = interpreter.count(expectation.entity, expectation.xpath)
+            unless actual_count == expectation.equals
+              failures << "#{expectation.entity} count #{actual_count}, expected #{expectation.equals}"
+            end
+          end
+          failures
+        end
+
+        def evaluated_arguments(arguments)
+          arguments.to_h.transform_values { Expression.new.evaluate(_1, {}) }
+        end
+
+        def monotonic_time
+          @clock.call(Process::CLOCK_MONOTONIC)
+        rescue ArgumentError
+          @clock.call
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/ClassLength, Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
+    end
+  end
+end

data/lib/mxrb/runtime/sql_server_database.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'json'
+
+module Mxrb
+  module Runtime
+    # Read-only query-plan connection to an explicitly configured SQL Server
+    # deployment. Credentials are passed through SQLCMDPASSWORD, never argv.
+    class SqlServerDatabase # rubocop:disable Metrics/ClassLength
+      MUTATING_SQL = /\b(?:ALTER|CREATE|DELETE|DROP|EXEC(?:UTE)?|INSERT|INTO|MERGE|TRUNCATE|UPDATE)\b/i
+
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(server:, database:, user:, password: ENV['MXRB_SQLSERVER_PASSWORD'],
+                     sqlcmd: 'sqlcmd', runner: nil)
+        @server = required(server, 'SQL Server host')
+        @database = required(database, 'SQL Server database')
+        @user = required(user, 'SQL Server user')
+        @password = required(password, 'MXRB_SQLSERVER_PASSWORD')
+        @sqlcmd = sqlcmd
+        @runner = runner || method(:capture)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def explain(sql, analyze: false)
+        statement = read_only_statement(sql)
+        mode = analyze ? 'STATISTICS XML' : 'SHOWPLAN_XML'
+        output = run!("SET #{mode} ON; #{statement}; SET #{mode} OFF;")
+        Oql::SqlServerPlanAnalyzer.new.analyze(extract_showplan(output))
+      end
+
+      def workload(limit: 20)
+        maximum = Integer(limit)
+        raise ArgumentError, 'workload limit must be between 1 and 1000' unless (1..1000).cover?(maximum)
+
+        Oql::SqlServerWorkloadAnalyzer.new.analyze(
+          query_rows: query_workload(maximum), table_rows: table_workload,
+          index_rows: index_workload
+        )
+      end
+
+      private
+
+      def query_workload(limit) # rubocop:disable Metrics/MethodLength
+        run_json(<<~SQL)
+          SELECT TOP (#{limit})
+            CONVERT(varchar(66), qs.query_hash, 1) AS query_hash,
+            SUBSTRING(st.text, (qs.statement_start_offset / 2) + 1,
+              ((CASE qs.statement_end_offset WHEN -1 THEN DATALENGTH(st.text)
+                ELSE qs.statement_end_offset END - qs.statement_start_offset) / 2) + 1) AS query_text,
+            qs.execution_count, qs.total_elapsed_time, qs.total_rows,
+            qs.total_logical_reads, qs.total_physical_reads
+          FROM sys.dm_exec_query_stats qs
+          CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) st
+          ORDER BY qs.total_elapsed_time DESC FOR JSON PATH
+        SQL
+      end
+
+      def table_workload
+        run_json(<<~SQL)
+          SELECT CONCAT(OBJECT_SCHEMA_NAME(i.object_id), '.', OBJECT_NAME(i.object_id)) AS relation,
+                 SUM(COALESCE(s.user_scans, 0)) AS user_scans,
+                 SUM(COALESCE(s.user_seeks, 0)) AS user_seeks
+          FROM sys.indexes i
+          LEFT JOIN sys.dm_db_index_usage_stats s
+            ON s.database_id = DB_ID() AND s.object_id = i.object_id AND s.index_id = i.index_id
+          WHERE i.object_id > 0
+          GROUP BY i.object_id FOR JSON PATH
+        SQL
+      end
+
+      def index_workload # rubocop:disable Metrics/MethodLength
+        run_json(<<~SQL)
+          SELECT CONCAT(OBJECT_SCHEMA_NAME(i.object_id), '.', OBJECT_NAME(i.object_id)) AS relation,
+                 i.name AS index_name, COALESCE(s.user_scans, 0) AS user_scans,
+                 COALESCE(s.user_seeks, 0) AS user_seeks,
+                 SUM(COALESCE(p.reserved_page_count, 0)) * 8192 AS index_bytes
+          FROM sys.indexes i
+          LEFT JOIN sys.dm_db_index_usage_stats s
+            ON s.database_id = DB_ID() AND s.object_id = i.object_id AND s.index_id = i.index_id
+          LEFT JOIN sys.dm_db_partition_stats p
+            ON p.object_id = i.object_id AND p.index_id = i.index_id
+          WHERE i.name IS NOT NULL
+          GROUP BY i.object_id, i.name, s.user_scans, s.user_seeks FOR JSON PATH
+        SQL
+      end
+
+      def run_json(sql)
+        source = run!(sql).strip
+        JSON.parse(source.empty? ? '[]' : source)
+      rescue JSON::ParserError => e
+        raise ToolchainError, "sqlcmd returned invalid workload JSON: #{e.message}"
+      end
+
+      def run!(sql)
+        environment = { 'SQLCMDPASSWORD' => @password }
+        command = [
+          @sqlcmd, '-S', @server, '-d', @database, '-U', @user,
+          '-C', '-b', '-h', '-1', '-W', '-y', '0', '-Q', sql
+        ]
+        output, error, status = @runner.call(environment, *command)
+        raise ToolchainError, "sqlcmd failed:\n#{output}#{error}" unless status.success?
+
+        output.to_s
+      end
+
+      def extract_showplan(output)
+        start = output.index('<ShowPlanXML')
+        finish = output.rindex('</ShowPlanXML>')
+        raise ToolchainError, 'sqlcmd returned no SHOWPLAN XML' unless start && finish
+
+        output[start..(finish + '</ShowPlanXML>'.length - 1)]
+      end
+
+      def read_only_statement(sql)
+        source = sql.to_s
+        raise ArgumentError, 'SQL contains a NUL byte' if source.include?("\0")
+
+        statement = source.strip
+        validate_read_only_statement!(statement)
+        statement
+      end
+
+      def validate_read_only_statement!(statement)
+        raise ArgumentError, 'SQL must not be empty' if statement.empty?
+        unless statement.match?(/\A(?:SELECT|WITH)\b/i) && !statement.include?(';')
+          raise ArgumentError, 'SQL Server plan analysis accepts one read-only SELECT or WITH statement'
+        end
+        return unless statement.match?(MUTATING_SQL)
+
+        raise ArgumentError, 'SQL Server plan analysis rejects mutating keywords, including writable CTEs'
+      end
+
+      def required(value, label)
+        text = value.to_s
+        raise ArgumentError, "#{label} is required" if text.empty? || text.include?("\0")
+
+        text
+      end
+
+      def capture(environment, *command)
+        Open3.capture3(environment, *command)
+      end
+    end
+  end
+end