mxrb 0.1.0

data/lib/mxrb/compiler/web_bundle_builder.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+
+module Mxrb
+  module Compiler
+    WebBundleResult = Data.define(:directory, :files, :bytes)
+
+    # Generates the web-client entrypoint and runs the version-owned Rspack toolchain directly.
+    # rubocop:disable Metrics
+    class WebBundleBuilder
+      include ModelValues
+
+      def initialize(mpr_path, deployment:, mendix_home:)
+        @mpr_path = File.expand_path(mpr_path)
+        @deployment = File.expand_path(deployment)
+        @source = SourceModel.read(@mpr_path)
+        @version_root = version_root(mendix_home)
+      end
+
+      def build
+        web = File.join(@deployment, 'web')
+        profiles = Adapter.for(@source.version, source: @source).web_profiles
+        return LegacyPageBuilder.new(@source, web, profiles:).build unless profiles.include?(:react)
+
+        prepare(web)
+        run_bundler(web)
+        WebShellMaterializer.new(web, version: @source.version).materialize
+        result(web)
+      end
+
+      private
+
+      def run_bundler(web)
+        output, status = Open3.capture2e(environment(web), node, *bundler_arguments, chdir: web)
+        raise CompilationError, "#{bundler_name} web build failed:\n#{output}" unless status.success?
+      end
+
+      def prepare(web)
+        WidgetPackageExtractor.new(File.dirname(@mpr_path), web).extract
+        materialize_react_dom_compatibility(web)
+        WebOperationCompiler.new(@source).write(File.join(@deployment, 'model', 'operations.json'))
+        PageBundleBuilder.new(@source, web).build
+        write_entry(File.join(web, 'index.js'))
+      end
+
+      def materialize_react_dom_compatibility(web)
+        shim = File.join(web, 'react-dom-compat.mjs')
+        react_dom = File.join(@version_root, 'modeler', 'tools', 'node', 'node_modules',
+                              'react-dom', 'index.js')
+        File.write(shim, <<~JS)
+          import * as ReactDOM from #{JSON.generate(react_dom)};
+          export * from #{JSON.generate(react_dom)};
+          export default ReactDOM;
+          export const findDOMNode = value => {
+            if (typeof Element !== "undefined" && value instanceof Element) return value;
+            const seen = new Set();
+            const pending = [value?._reactInternals, value?._reactInternalFiber].filter(Boolean);
+            while (pending.length) {
+              const fiber = pending.shift();
+              if (!fiber || seen.has(fiber)) continue;
+              seen.add(fiber);
+              if (typeof Element !== "undefined" && fiber.stateNode instanceof Element) {
+                return fiber.stateNode;
+              }
+              pending.push(fiber.child, fiber.sibling);
+            }
+            return null;
+          };
+        JS
+        config_path = File.join(web, 'rspack.config.mjs')
+        return unless File.file?(config_path)
+
+        config = File.read(config_path)
+        return if config.include?(JSON.generate(shim))
+
+        marker = 'alias: {'
+        replacement = "#{marker}\n            \"react-dom\": #{JSON.generate(shim)},"
+        raise CompilationError, 'Rspack config has no resolve alias block' unless config.include?(marker)
+
+        File.write(config_path, config.sub(marker, replacement))
+      end
+
+      def version_root(path)
+        root = File.expand_path(path)
+        File.basename(root) == 'runtime' ? File.dirname(root) : root
+      end
+
+      def result(web)
+        directory = File.join(web, 'dist')
+        files = Dir.glob(File.join(directory, '**', '*')).select { File.file?(_1) }
+        WebBundleResult.new(directory:, files: files.length, bytes: files.sum { File.size(_1) })
+      end
+
+      def node = File.join(@version_root, 'modeler', 'tools', 'node', 'linux-x64', 'node')
+      def bundler_name = @source.version.to_i == 10 ? 'Rollup' : 'Rspack'
+
+      def bundler_arguments
+        return [File.join(node_modules, 'rollup', 'dist', 'bin', 'rollup'), '--config'] if @source.version.to_i == 10
+
+        [File.join(@version_root, 'modeler', 'tools', 'node', 'rspack-runner.mjs')]
+      end
+
+      def node_modules = File.join(@version_root, 'modeler', 'tools', 'node', 'node_modules')
+
+      def environment(web)
+        {
+          'NODE_ENV' => 'production', 'SOURCE_MAP_GENERATION' => 'disabled',
+          'SHOULD_GENERATE_EMBEDDED_INDEX' => 'false',
+          'MX_DEPLOYMENT_WEB_DIRECTORY' => web,
+          'MX_WEB_CLIENT_BUILD_LOG' => File.join(@deployment, 'log', 'mxrb-web-build.log'),
+          'NODE_PATH' => node_modules
+        }
+      end
+
+      def write_entry(path)
+        payload = {
+          languages: languages, systemTexts: rendered_system_texts,
+          constants: { LAYOUT_SCOPE_ID_PREFIX: 'l' },
+          registerServiceWorker: false, enableServiceWorkerCaching: true
+        }
+        File.write(path, "import { startApp } from \"mendix\";\n\nstartApp(#{JSON.pretty_generate(payload)});\n")
+      end
+
+      def languages
+        values = translations.values.flat_map(&:keys).uniq.sort
+        values.empty? ? ['en_US'] : values
+      end
+
+      def rendered_system_texts
+        translations.transform_values do |values|
+          languages.map { values.fetch(_1, '') }
+        end
+      end
+
+      def translations
+        @translations ||= collect_translations
+      end
+
+      def collect_translations
+        collection = @source.documents('Texts$SystemTextCollection').first
+        return {} unless collection
+
+        array(collection['SystemTexts']).to_h do |text|
+          translations = array(text.dig('Text', 'Items')).to_h do |item|
+            [item['LanguageCode'].to_s, item['Text'].to_s]
+          end
+          [text['InternalKey'].to_s, translations]
+        end
+      end
+    end
+    # rubocop:enable Metrics
+  end
+end

data/lib/mxrb/compiler/web_list_data_source.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Compiler
+    # Resolves React list data sources and safely lowers unusable simple connector reads to XPath.
+    # rubocop:disable Metrics
+    class WebListDataSource
+      include ModelValues
+
+      attr_reader :association_path, :entity, :microflow_name, :nanoflow_name, :xpath_constraint
+
+      def initialize(source, widget)
+        @source = source
+        @widget = widget
+        resolve_sources
+        resolve_flows
+        resolve_entity
+        @xpath_constraint = @xpath&.fetch('XPathConstraint', '').to_s
+      end
+
+      def resolve_sources
+        direct = widget['DataSource'] if widget.is_a?(Hash)
+        @xpath = direct if database_source?(direct)
+        @xpath ||= nested(widget, 'CustomWidgets$CustomWidgetXPathSource').first
+        @association_source = direct if direct&.fetch('$Type', nil) == 'Forms$AssociationSource'
+        @association_source ||= nested(widget, 'Forms$AssociationSource').first
+        @microflow_source = direct if direct&.fetch('$Type', nil) == 'Forms$MicroflowSource'
+        @microflow_source ||= nested(widget, 'Forms$MicroflowSource').first
+        @nanoflow_source = direct if direct&.fetch('$Type', nil) == 'Forms$NanoflowSource'
+        @nanoflow_source ||= nested(widget, 'Forms$NanoflowSource').first
+        @microflow_name = flow_name(@microflow_source, 'Microflow')
+        @nanoflow_name = @nanoflow_source&.fetch('Nanoflow', '').to_s
+        @association_path = entity_ref_path(@association_source&.fetch('EntityRef', nil))
+      end
+
+      def flow_name(source, key)
+        source&.dig("#{key}Settings", key).to_s.then do |name|
+          name.empty? ? source&.fetch(key, '').to_s : name
+        end
+      end
+
+      def resolve_flows
+        @flow = qualified_unit('Microflows$Microflow', microflow_name) unless microflow_name.empty?
+        @nanoflow = qualified_unit('Microflows$Nanoflow', nanoflow_name) unless nanoflow_name.empty?
+      end
+
+      def resolve_entity
+        @entity = [
+          entity_ref_destination(@xpath&.fetch('EntityRef', nil)),
+          entity_ref_destination(@association_source&.fetch('EntityRef', nil)),
+          @flow&.document&.dig('MicroflowReturnType', 'Entity'),
+          @nanoflow&.document&.dig('MicroflowReturnType', 'Entity')
+        ].map(&:to_s).find { !_1.empty? }.to_s
+      end
+
+      def supported? = xpath? || association? || microflow? || nanoflow?
+      def xpath? = !@xpath.nil? || connector_fallback?
+      def association? = !@association_source.nil? && !association_path.empty? && !entity.empty?
+      def microflow? = !@microflow_source.nil? && !microflow_name.empty? && !@flow.nil?
+      def nanoflow? = !@nanoflow_source.nil? && !nanoflow_name.empty? && !@nanoflow.nil?
+
+      private
+
+      attr_reader :widget
+
+      def database_source?(source)
+        %w[Forms$DatabaseSource Forms$NewListViewDatabaseSource Forms$ListViewXPathSource]
+          .include?(source&.fetch('$Type', nil))
+      end
+
+      def entity_ref_destination(reference)
+        steps = array(reference&.fetch('Steps', nil))
+        steps.last&.fetch('DestinationEntity', nil) || reference&.fetch('Entity', nil)
+      end
+
+      def entity_ref_path(reference)
+        array(reference&.fetch('Steps', nil)).flat_map do |step|
+          [step['Association'], step['DestinationEntity']]
+        end.map(&:to_s).reject(&:empty?).join('/')
+      end
+
+      def connector_fallback?
+        return @connector_fallback unless @connector_fallback.nil?
+
+        @connector_fallback = connector_action.then do |action|
+          action && simple_unconfigured_query?(action)
+        end
+      end
+
+      def connector_action
+        actions = nested(@flow&.document, 'DatabaseConnector$ExecuteDatabaseQueryAction')
+        actions.one? ? actions.first : nil
+      end
+
+      def simple_unconfigured_query?(action)
+        connection, query = connector_query(action['Query'].to_s)
+        return false unless connection && query && connection_unconfigured?(connection)
+        return false unless query['Query'].to_s.match?(/\A\s*select\s+.+\s+from\s+[A-Za-z_][A-Za-z0-9_]*\s*;?\s*\z/im)
+
+        mappings = array(query['TableMappings'])
+        mappings.one? && mappings.first['Entity'].to_s == entity
+      end
+
+      def connector_query(qualified)
+        connection_name, _, query_name = qualified.rpartition('.')
+        unit = @source.units.find do |candidate|
+          candidate.document['$Type'] == 'DatabaseConnector$DatabaseConnection' &&
+            "#{candidate.module_name}.#{candidate.document['Name']}" == connection_name
+        end
+        [unit&.document, array(unit&.document&.fetch('Queries', nil)).find { _1['Name'] == query_name }]
+      end
+
+      def connection_unconfigured?(connection)
+        %w[ConnectionString UserName Password].all? do |field|
+          name = connection[field].to_s
+          constant = qualified_unit('Constants$Constant', name) unless name.empty?
+          constant && constant.document.fetch('DefaultValue', nil).to_s.empty?
+        end
+      end
+
+      def qualified_unit(type, qualified)
+        @source.units_of(type).find do |unit|
+          "#{unit.module_name}.#{unit.document['Name']}" == qualified
+        end
+      end
+
+      def nested(value, type, result = [])
+        case value
+        when Hash
+          result << value if value['$Type'] == type
+          value.each_value { nested(_1, type, result) }
+        when Array then value.each { nested(_1, type, result) }
+        end
+        result
+      end
+    end
+    # rubocop:enable Metrics
+  end
+end