mxrb 0.1.0

data/lib/mxrb/compiler/constants_materializer.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'tmpdir'
+
+module Mxrb
+  module Compiler
+    ConstantsMaterialization = Data.define(:model_path, :metadata_path, :constants)
+
+    # Compiles MPR constants into Runtime model and metadata representations.
+    class ConstantsMaterializer
+      DATA_TYPES = {
+        'DataTypes$StringType' => 'String', 'DataTypes$IntegerType' => 'Integer',
+        'DataTypes$BooleanType' => 'Boolean', 'DataTypes$DecimalType' => 'Decimal',
+        'DataTypes$DateTimeType' => 'DateTime'
+      }.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)
+        constants = compile(source)
+        model_path = File.join(@deployment, 'model', 'model.mdp')
+        metadata_path = File.join(@deployment, 'model', 'metadata.json')
+        write_model(model_path, constants)
+        metadata_constants = write_metadata(metadata_path, constants)
+        ConstantsMaterialization.new(
+          model_path:, metadata_path:, constants: metadata_constants.freeze
+        )
+      end
+
+      private
+
+      def compile(source)
+        source.units_of('Constants$Constant').map do |unit|
+          raise CompilationError, "constant #{unit.document['Name']} is outside a module" unless unit.module_name
+
+          compile_constant(source, unit)
+        end
+      end
+
+      def compile_constant(source, unit)
+        document = unit.document
+        qualified_name = "#{unit.module_name}.#{document['Name']}"
+        data_type = constant_type(document, qualified_name)
+        {
+          module_name: unit.module_name, runtime: runtime_document(document, qualified_name, data_type, source),
+          metadata: metadata_document(document, qualified_name, data_type)
+        }
+      end
+
+      def constant_type(document, qualified_name)
+        native = document.dig('Type', '$Type')
+        legacy = document['DataType'].to_s
+        return legacy if DATA_TYPES.value?(legacy)
+
+        DATA_TYPES.fetch(native) do
+          raise CompilationError, "unsupported constant type #{native.inspect} for #{qualified_name}"
+        end
+      end
+
+      def runtime_document(source, qualified_name, data_type, model)
+        {
+          '$ID' => source['$ID'], '$Type' => source['$Type'], 'Name' => source['Name'],
+          'QualifiedName' => qualified_name, 'DataType' => data_type,
+          'ExposedToClient' => model.client_reference?(qualified_name)
+        }
+      end
+
+      def metadata_document(source, qualified_name, data_type)
+        {
+          'Name' => qualified_name, 'Type' => data_type,
+          'Description' => source['Documentation'].to_s,
+          'DefaultValue' => source['DefaultValue'].to_s
+        }
+      end
+
+      def write_metadata(path, constants)
+        metadata = JSON.parse(File.read(path))
+        metadata['Constants'] = ordered_metadata(constants)
+        atomic_json_write(path, metadata)
+        metadata.fetch('Constants')
+      end
+
+      def ordered_metadata(constants)
+        constants.group_by { _1.fetch(:module_name) }
+                 .flat_map { |_module, entries| entries.sort_by { _1.dig(:metadata, 'Name') } }
+                 .map { _1.fetch(:metadata) }
+      end
+
+      def write_model(path, constants)
+        package = constants.reduce(ModelPackage.read(path)) do |result, constant|
+          result.upsert(constant.fetch(:runtime))
+        end
+        package.write(path)
+      end
+
+      def atomic_json_write(path, document)
+        Dir.mktmpdir('mxrb-metadata-', File.dirname(path)) do |directory|
+          temporary = File.join(directory, 'metadata.json')
+          File.write(temporary, JSON.pretty_generate(document))
+          FileUtils.mv(temporary, path, force: true)
+        end
+      end
+    end
+  end
+end

data/lib/mxrb/compiler/data_grid_bundle_compiler.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Mxrb
+  module Compiler
+    # Compiles the Data Grid 2 XPath/attribute-column subset into pluggable-widget properties.
+    # rubocop:disable Metrics
+    class DataGridBundleCompiler
+      include ModelValues
+
+      WIDGET_ID = 'com.mendix.widget.web.datagrid.Datagrid'
+
+      def initialize(source, page_name, widget = nil, render_widgets: nil, **widget_keywords)
+        @source = source
+        @page_name = page_name
+        @widget = widget || widget_keywords
+        @render_widgets = render_widgets
+        @index = document_index
+      end
+
+      def supported?
+        widget_type&.fetch('WidgetId', nil) == WIDGET_ID && xpath_source &&
+          columns.all? { supported_column?(_1) }
+      end
+
+      def render
+        "React.createElement($Datagrid, #{js_object(properties)})"
+      end
+
+      private
+
+      def properties
+        values = property_values(@widget['Object'])
+        primitives(values).merge(
+          key: widget_key, '$widgetId': widget_key, advanced: false,
+          datasource: datasource, columns: columns.map { compile_column(_1) },
+          class: css_class
+        )
+      end
+
+      def primitives(values)
+        values.each_with_object({}) do |(key, pair), result|
+          type, value = pair
+          compiled = primitive(type, value)
+          result[key.to_sym] = compiled unless compiled.equal?(:undefined)
+        end
+      end
+
+      def primitive(type, value) # rubocop:disable Metrics/CyclomaticComplexity
+        compiled = case type
+                   when 'Boolean' then value['PrimitiveValue'] == 'true'
+                   when 'Integer' then value['PrimitiveValue'].to_i
+                   when 'Enumeration' then value['PrimitiveValue'].to_s
+                   when 'TextTemplate' then expression(translated_text(value['TextTemplate']))
+                   when 'Widgets' then [] if array(value['Widgets']).empty?
+                   end
+        compiled.nil? ? :undefined : compiled
+      end # rubocop:enable Metrics/CyclomaticComplexity
+
+      def datasource
+        {
+          '$raw' => "DatabaseObjectListProperty(#{js_object(
+            dataSourceId: data_source_id, entity: entity_name,
+            operationId: WebOperationCompiler.operation_id(@page_name, @widget['Name']), sort: []
+          )})"
+        }
+      end
+
+      def compile_column(object) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        values = property_values(object)
+        mode = values.fetch('showContentAs').last['PrimitiveValue']
+        attribute = attribute_name(values)
+        entity, name = attribute.rpartition('.').then { |prefix, _, suffix| [prefix, suffix] }
+        result = primitives(values).merge(
+          showContentAs: mode, attribute: attribute.empty? ? :undefined : raw_attribute(entity, name),
+          dynamicText: :undefined, header: expression(text_value(values['header']&.last)),
+          tooltip: :undefined, filter: compile_widgets(values['filter']&.last),
+          visible: expression(true), exportValue: :undefined
+        )
+        result[:dynamicText] = dynamic_text(values, entity, name) if mode == 'dynamicText'
+        result[:content] = templated_content(values) if mode == 'customContent'
+        result.merge!(association_filter(values)) if association_filter?(values)
+        result
+      end # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def association_filter?(values)
+        !association_steps(values).empty? && !filter_widget(values).nil?
+      end
+
+      def association_filter(values) # rubocop:disable Metrics/AbcSize
+        filter = filter_widget(values)
+        steps = association_steps(values)
+        steps.flat_map { [_1['Association'], _1['DestinationEntity']] }.join('/')
+        association = steps.first['Association'].to_s
+        endpoint = steps.last['DestinationEntity'].to_s
+        caption = attribute_name(values).split('.').last
+        selectable_id = "#{data_source_id}$#{filter['Name']}"
+        operation_id = WebOperationCompiler.operation_id(
+          @page_name, "#{@widget['Name']}$#{filter['Name']}"
+        )
+        {
+          filterAssociation: raw_property('ListAssociationProperty', {
+            type: filter_boolean(filter, 'multiSelect') ? 'ReferenceSet' : 'Reference',
+            entity: :undefined, path: '', attribute: association, endpointEntity: endpoint,
+            selectableObjectsId: selectable_id, filterable: true, dataSourceId: data_source_id
+          }),
+          filterAssociationOptions: raw_property('DatabaseObjectListProperty', {
+            dataSourceId: selectable_id, entity: endpoint, operationId: operation_id,
+            sort: [[caption, 'asc']]
+          }),
+          filterAssociationOptionLabel: raw_property('ListExpressionProperty', {
+            expression: {
+              expr: { type: 'variable', variable: 'currentObject', path: caption },
+              args: { currentObject: { widget: widget_key, source: 'object' } }
+            }, dataSourceId: selectable_id
+          })
+        }
+      end
+
+      def raw_property(name, config) = { '$raw' => "#{name}(#{js_object(config)})" }
+
+      def filter_widget(values)
+        array(values['filter']&.last&.fetch('Widgets', nil)).first
+      end
+
+      def association_steps(values)
+        array(values['attribute']&.last&.dig('AttributeRef', 'EntityRef', 'Steps'))
+      end
+
+      def filter_boolean(widget, key)
+        property_values(widget['Object'])[key]&.last&.fetch('PrimitiveValue', nil) == 'true'
+      end
+
+      def dynamic_text(values, entity, name)
+        template = values['dynamicText']&.last&.fetch('TextTemplate', nil)
+        parameters = array(template&.fetch('Parameters', nil))
+        return :undefined unless parameters.one? && !name.empty?
+
+        variable = { type: 'variable', variable: 'currentObject', path: name }
+        expr = if attribute_type(entity, name) == 'DateTime'
+                 { type: 'function', name: '_format',
+                   parameters: [variable, { type: 'literal', value: JSON.generate(type: 'datetime') }] }
+               else
+                 variable
+               end
+        raw_list_expression(expr)
+      end
+
+      def raw_list_expression(expr)
+        payload = {
+          expression: { expr:, args: { currentObject: { widget: widget_key, source: 'object' } } },
+          dataSourceId: data_source_id
+        }
+        { '$raw' => "ListExpressionProperty(#{js_object(payload)})" }
+      end
+
+      def templated_content(values)
+        widgets = array(values['content']&.last&.fetch('Widgets', nil))
+        rendered = @render_widgets.call(widgets, widget_key, entity_name)
+        { '$raw' => "TemplatedWidgetProperty(#{js_object(
+          dataSourceId: data_source_id, editable: false,
+          children: { '$raw' => "() => #{rendered}" }
+        )})" }
+      end
+
+      def compile_widgets(value)
+        widgets = array(value&.fetch('Widgets', nil))
+        return [] if widgets.empty?
+
+        { '$raw' => @render_widgets.call(widgets, widget_key, entity_name) }
+      end
+
+      def raw_attribute(entity, name)
+        {
+          '$raw' => "AttributeProperty(#{js_object(
+            path: '', entity:, attribute: name, attributeType: attribute_type(entity, name),
+            sortable: true, filterable: true, dataSourceId: data_source_id, isList: false
+          )})"
+        }
+      end
+
+      def expression(value)
+        payload = { expression: { expr: { type: 'literal', value: }, args: {} } }
+        { '$raw' => "ExpressionProperty(#{js_object(payload)})" }
+      end
+
+      def js_object(value)
+        pairs = value.map { |key, item| "#{JSON.generate(key)}: #{js_value(item)}" }
+        "{ #{pairs.join(', ')} }"
+      end
+
+      def js_value(value)
+        return value['$raw'] if value.is_a?(Hash) && value.key?('$raw')
+        return 'undefined' if value == :undefined
+        return "[#{value.map { js_value(_1) }.join(', ')}]" if value.is_a?(Array)
+        return js_object(value) if value.is_a?(Hash)
+
+        JSON.generate(value)
+      end
+
+      def property_values(object)
+        array(object&.fetch('Properties', nil)).filter_map do |property|
+          type = @index[IO::BsonCodec.extract_id(property['TypePointer'])]
+          next unless type
+
+          [type.fetch('PropertyKey'), [type.dig('ValueType', 'Type'), property['Value']]]
+        end.to_h
+      end
+
+      def columns
+        value = property_values(@widget['Object']).fetch('columns').last
+        array(value['Objects'])
+      end
+
+      def supported_column?(object)
+        values = property_values(object)
+        mode = values['showContentAs']&.last&.fetch('PrimitiveValue', nil)
+        return attribute_name(values).include?('.') if %w[attribute dynamicText].include?(mode)
+        return false unless mode == 'customContent' && @render_widgets
+
+        array(values['content']&.last&.fetch('Widgets', nil)).any?
+      end
+
+      def attribute_name(values) = values['attribute']&.last&.dig('AttributeRef', 'Attribute').to_s
+
+      def xpath_source
+        property_values(@widget['Object'])['datasource']&.last&.fetch('DataSource', nil)
+      end
+
+      def entity_name = xpath_source.dig('EntityRef', 'Entity').to_s
+      def data_source_id = "p.#{Digest::SHA256.hexdigest(widget_key)[0, 6].to_i(16)}"
+      def widget_key = "p.#{@page_name}.#{@widget['Name']}"
+
+      def css_class
+        ["mx-name-#{@widget['Name']}", @widget.dig('Appearance', 'Class')]
+          .map(&:to_s).reject(&:empty?).uniq.join(' ')
+      end
+
+      def translated_text(text)
+        items = array(text&.dig('Template', 'Items'))
+        items.find { _1['LanguageCode'] == 'en_US' }&.fetch('Text', '') ||
+          items.first&.fetch('Text', '') || ''
+      end
+
+      def text_value(value) = translated_text(value&.fetch('TextTemplate', nil))
+
+      def attribute_type(entity, name) # rubocop:disable Metrics/AbcSize
+        document = @source.units_of('DomainModels$DomainModel').filter_map do |unit|
+          next unless unit.module_name == entity.split('.').first
+
+          array(unit.document['Entities']).find { _1['Name'] == entity.split('.').last }
+        end.first
+        attribute = array(document&.fetch('Attributes', nil)).find { _1['Name'] == name }
+        attribute_type_name(attribute&.fetch('NewType', nil))
+      end # rubocop:enable Metrics/AbcSize
+
+      def attribute_type_name(type)
+        type_name = type&.fetch('$Type', '').to_s.delete_prefix('DomainModels$')
+        type_name.delete_suffix('AttributeType').then { _1.empty? ? 'String' : _1 }
+      end
+
+      def widget_type
+        object_type_id = IO::BsonCodec.extract_id(@widget.dig('Object', 'TypePointer'))
+        return unless object_type_id
+
+        @index.values.find do |document|
+          IO::BsonCodec.extract_id(document.dig('ObjectType', '$ID')) == object_type_id
+        end
+      end
+
+      def document_index
+        return @source.document_index if @source.is_a?(SourceModel)
+
+        {}.tap { |index| @source.documents.each { index_document(_1, index) } }
+      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
+    # rubocop:enable Metrics
+  end
+end

data/lib/mxrb/compiler/database_connector_action_compiler.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'json'
+
+module Mxrb
+  module Compiler
+    # Mirrors Mendix's Database Connector build extension by lowering custom activities to Java calls.
+    # The mapping mirrors one cohesive external build-extension contract.
+    # rubocop:disable Metrics/AbcSize, Metrics/ClassLength, Metrics/CyclomaticComplexity,
+    # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
+    class DatabaseConnectorActionCompiler
+      include ModelValues
+
+      def initialize(source)
+        @source = source
+        @connections = connection_index
+      end
+
+      def compile(action)
+        connection, query = resolve_query(action['Query'].to_s)
+        java_action = java_action_for(query)
+        mappings = basic_mappings(action, connection, query, java_action)
+        mappings.concat(result_mappings(query, java_action))
+        {
+          '$ID' => action['$ID'], '$Type' => 'Microflows$JavaActionCallAction',
+          'QueueSettings' => nil, 'ParameterMappings' => mappings,
+          'ErrorHandlingType' => action['ErrorHandlingType'], 'JavaAction' => java_action,
+          'ResultVariableName' => action['OutputVariableName'].to_s,
+          'UseReturnVariable' => true
+        }
+      end
+
+      def unconfigured_write?(action)
+        return false unless action&.fetch('$Type', nil) == 'DatabaseConnector$ExecuteDatabaseQueryAction'
+
+        connection, query = resolve_query(action['Query'].to_s)
+        return false if selecting_query?(query)
+
+        override = array(action['ConnectionParameterMappings']).find do |mapping|
+          mapping['ParameterName'].to_s.casecmp('DBSource').zero?
+        end
+        return false unless override.nil? || override['Value'].to_s.strip.empty?
+
+        constant_name = connection['ConnectionString'].to_s
+        constant = @source.units.find do |unit|
+          unit.document['$Type'] == 'Constants$Constant' &&
+            "#{unit.module_name}.#{unit.document['Name']}" == constant_name
+        end
+        constant && constant.document['DefaultValue'].to_s.empty?
+      end
+
+      private
+
+      def connection_index
+        @source.units.each_with_object({}) do |unit, result|
+          next unless unit.document['$Type'] == 'DatabaseConnector$DatabaseConnection'
+
+          result["#{unit.module_name}.#{unit.document['Name']}"] = unit.document
+        end
+      end
+
+      def resolve_query(qualified)
+        connection_name, _, query_name = qualified.rpartition('.')
+        connection = @connections[connection_name]
+        raise CompilationError, "database connection #{connection_name.inspect} not found" unless connection
+
+        query = array(connection['Queries']).find { _1['Name'] == query_name }
+        raise CompilationError, "database query #{qualified.inspect} not found" unless query
+
+        [connection, query]
+      end
+
+      def java_action_for(query)
+        sql = remove_comments(query['Query'].to_s).downcase
+        selecting = selecting_sql?(sql)
+        mapped = array(query['TableMappings']).any?
+        if selecting
+          return mapped ? 'ExternalDatabaseConnector.ExecuteQuery' : 'ExternalDatabaseConnector.ExecuteStatement'
+        end
+        return statement_action(mapped) unless callable?(query, sql)
+        return 'ExternalDatabaseConnector.ExecuteCallable' if query['QueryType'].to_i == 3
+
+        if mapped
+          'ExternalDatabaseConnector.ExecuteCallableQuery'
+        else
+          'ExternalDatabaseConnector.ExecuteCallableStatement'
+        end
+      end
+
+      def selecting_query?(query)
+        selecting_sql?(remove_comments(query['Query'].to_s).downcase)
+      end
+
+      def selecting_sql?(sql)
+        (sql.start_with?('select ') && !sql.include?(' into ')) || sql.start_with?('with ')
+      end
+
+      def statement_action(mapped)
+        mapped ? 'ExternalDatabaseConnector.ExecuteQuery' : 'ExternalDatabaseConnector.ExecuteStatement'
+      end
+
+      def callable?(query, sql)
+        return true if query['QueryType'].to_i == 3
+        return false unless query['QueryType'].to_i.zero?
+
+        sql.match?(/\A\s*(?:\{\s*)?(?:call|exec(?:ute)?)\b/i)
+      end
+
+      def basic_mappings(action, connection, query, java_action)
+        values = {
+          'connectionDetails' => expression_literal(connection_json(action, connection)),
+          'sql' => expression_literal(runtime_query(action, query)),
+          'queryParameters' => expression_literal(parameters_json(action, query))
+        }
+        values.map.with_index { |(name, value), index| parameter_mapping(action, java_action, name, value, index) }
+      end
+
+      def result_mappings(query, java_action)
+        return [] unless %w[
+          ExternalDatabaseConnector.ExecuteQuery ExternalDatabaseConnector.ExecuteCallableQuery
+          ExternalDatabaseConnector.ExecuteCallable
+        ].include?(java_action)
+
+        table = array(query['TableMappings']).first
+        return [] unless table
+
+        column_mapping = JSON.generate(
+          'EntityName' => table['Entity'].to_s,
+          'ColumnAttributeMapping' => array(table['Columns']).to_h do |column|
+            [column['ColumnName'].to_s, column['Attribute'].to_s.split('.').last]
+          end
+        )
+        offset = 10
+        [
+          parameter_mapping(query, java_action, 'columnMapping', expression_literal(column_mapping), offset),
+          entity_parameter_mapping(query, java_action, 'OutputEntity', table['Entity'].to_s, offset + 1)
+        ]
+      end
+
+      def connection_json(action, connection)
+        overrides = array(action['ConnectionParameterMappings']).to_h do |mapping|
+          [mapping['ParameterName'].to_s.downcase, mapping['Value'].to_s]
+        end
+        values = {
+          'UserName' => raw(connection_value(overrides, connection, 'DBUsername', 'UserName')),
+          'Password' => raw(connection_value(overrides, connection, 'DBPassword', 'Password')),
+          'ConnectionString' => raw(connection_value(overrides, connection, 'DBSource', 'ConnectionString')),
+          'DatabaseType' => connection['DatabaseType'].to_s,
+          'AdditionalProperties' => additional_properties(overrides, connection)
+        }
+        raw_json(values)
+      end
+
+      def connection_value(overrides, connection, parameter, field)
+        expression = overrides[parameter.downcase]
+        expression ||= "@#{connection[field]}" unless connection[field].to_s.empty?
+        expression ||= "''"
+        "'+(#{expression})+'"
+      end
+
+      def additional_properties(overrides, connection)
+        array(connection['AdditionalProperties']).to_h do |property|
+          value = property['Value'] || {}
+          expression = overrides[property['Key'].to_s.downcase]
+          rendered = if expression
+                       raw("'+(#{expression})+'")
+                     elsif value['$Type'] == 'DatabaseConnector$ValueAsConstant'
+                       raw("'+(@#{value['Value']})+'")
+                     else
+                       value['Value'].to_s
+                     end
+          [property['Key'].to_s, rendered]
+        end
+      end
+
+      def runtime_query(action, query)
+        dynamic = action['DynamicQuery'].to_s
+        return "'+(#{dynamic})+'" unless dynamic.strip.empty?
+
+        sql = query['Query'].to_s
+        sql = query_builder_select(query) if sql.strip.empty?
+        sql.gsub("'", "''")
+      end
+
+      def query_builder_select(query)
+        table = array(query['TableMappings']).first
+        columns = table && array(table['Columns']).filter_map { valid_identifier(_1['ColumnName']) }
+        name = table && valid_identifier(table['TableName'])
+        unless name && columns.any?
+          raise CompilationError, 'database query builder has no executable table and column mapping'
+        end
+
+        "SELECT #{columns.join(', ')} FROM #{name}"
+      end
+
+      def valid_identifier(value)
+        identifier = value.to_s
+        return identifier if identifier.match?(/\A[A-Za-z_][A-Za-z0-9_$]*(?:\.[A-Za-z_][A-Za-z0-9_$]*)*\z/)
+
+        raise CompilationError, "unsafe database identifier #{identifier.inspect}"
+      end
+
+      def parameters_json(action, query)
+        mappings = array(action['ParameterMappings']).to_h do |mapping|
+          [mapping['ParameterName'].to_s.downcase, mapping['Value'].to_s]
+        end
+        result = {}
+        array(query['Parameters']).each_with_index do |parameter, index|
+          type = parameter.dig('DataType', '$Type').to_s.sub(/\ADataTypes\$/, '').sub(/Type\z/, '').upcase
+          value = parameter_value(type, mappings[parameter['ParameterName'].to_s.downcase])
+          result[(index + 1).to_s] = {
+            'Name' => parameter['ParameterName'], 'DataType' => type,
+            'SqlDataType' => parameter.dig('SqlDataType', 'DataTypeName').to_s,
+            'Value' => value && raw(value), 'ParameterMode' => parameter['Mode'].to_s,
+            'DatabaseParameterName' => parameter['DatabaseParameterName'].to_s,
+            'ParameterEntityMapping' => nil
+          }
+        end
+        raw_json(result)
+      end
+
+      def parameter_value(type, expression)
+        case type
+        when 'DATETIME' then "'+(if (#{expression}) = NULL then NULL else dateTimeToEpoch(#{expression}))+'"
+        when 'BOOLEAN' then "'+toString(#{expression})+'"
+        when 'STRING'
+          "'+(if (#{expression}) = NULL then NULL else (if (#{expression}) = 'null' then " \
+            "'903be4ca-ed8b-ddcb-a339-741c4088484a' else (urlEncode(#{expression}))))+'"
+        when 'INTEGER', 'DECIMAL' then "'+(#{expression})+'"
+        else raise CompilationError, "unsupported database parameter type #{type.inspect}"
+        end
+      end
+
+      def expression_literal(value) = "'#{value}'"
+
+      def parameter_mapping(seed, java_action, name, value, index)
+        {
+          '$ID' => derived_id(seed, "mapping-#{index}"), '$Type' => 'Microflows$JavaActionParameterMapping',
+          'Parameter' => "#{java_action}.#{name}",
+          'Value' => {
+            '$ID' => derived_id(seed, "value-#{index}"),
+            '$Type' => 'Microflows$BasicCodeActionParameterValue', 'ValueExpression' => value
+          }
+        }
+      end
+
+      def entity_parameter_mapping(seed, java_action, name, entity, index)
+        {
+          '$ID' => derived_id(seed, "mapping-#{index}"), '$Type' => 'Microflows$JavaActionParameterMapping',
+          'Parameter' => "#{java_action}.#{name}",
+          'Value' => {
+            '$ID' => derived_id(seed, "value-#{index}"),
+            '$Type' => 'Microflows$EntityTypeCodeActionParameterValue',
+            'Entity' => entity, 'ValueExpression' => "'#{entity}'"
+          }
+        }
+      end
+
+      def raw(value) = { '__mxrb_raw__' => value }
+
+      def raw_json(value)
+        rendered = JSON.generate(value)
+        rendered.gsub(/\{"__mxrb_raw__":"((?:\\.|[^"\\])*)"\}/) do
+          JSON.parse(%("#{Regexp.last_match(1)}"))
+        end
+      end
+
+      def remove_comments(sql) = sql.gsub(%r{/\*[\s\S]*?\*/|--.*}, '').strip
+
+      def derived_id(source, label)
+        seed = "#{IO::BsonCodec.extract_id(source['$ID'])}:database-connector:#{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