mxrb 0.1.1 → 0.1.3

data/lib/mxrb/scaffold/generator.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'securerandom'
+
 module Mxrb
   module Scaffold
     # Creates conventional Ruby-first artifacts and connects missing aggregators.
@@ -24,8 +26,7 @@ module Mxrb
         @root = File.expand_path(target)
         @transaction = Transaction.new
         @dry_run = dry_run
-        @page_chain = page_options.delete(:page_chain)
-        @page_template = page_options.delete(:page_template)
+        assign_options(page_options)
         raise ArgumentError, "unknown generator options: #{page_options.keys.join(', ')}" unless
           page_options.empty?
       end
@@ -42,6 +43,13 @@ module Mxrb
 
       private
 
+      def assign_options(options)
+        @page_chain = options.delete(:page_chain)
+        @page_template = options.delete(:page_template)
+        @demo_entity = options.delete(:demo_entity)
+        @demo_roles = options.delete(:demo_roles)
+      end
+
       def page_chain
         return unless @page_chain
         return @page_chain if PAGE_CHAINS.include?(@page_chain)
@@ -55,8 +63,13 @@ module Mxrb
       end
 
       def stage_registry
+        files = @transaction.created.dup
+        if @kind == :demo_user
+          shared = [project_path('.env'), project_path('.env.example')]
+          files -= shared
+        end
         Registry.stage(
-          @transaction, root: @root, key: "#{@kind}:#{@name}", files: @transaction.created.dup
+          @transaction, root: @root, key: "#{@kind}:#{@name}", files:
         )
       end
 
@@ -125,6 +138,115 @@ module Mxrb
         @transaction.write(path, lines.join)
       end
 
+      def connect_project_demo_users
+        path = project_path('project.rb')
+        source = connect_project_dotenv(@transaction.content(path))
+        opening = source.lines.index { _1.match?(/^\s*security do\s*$/) }
+        raise ArgumentError, security_initialization_error unless opening
+
+        insert_demo_user_loader(path, source, opening)
+      end
+
+      def insert_demo_user_loader(path, source, opening)
+        line = 'evaluate_dir File.join(__dir__, "app", "security", "demo_users")'
+        return if source.include?(line)
+
+        lines = source.lines
+        indentation = "#{lines.fetch(opening)[/^\s*/]}  "
+        lines.insert(opening + 1, "#{indentation}#{line}\n")
+        @transaction.write(path, lines.join)
+      end
+
+      def connect_project_dotenv(source)
+        dotenv_line = 'Dotenv.load(File.join(__dir__, ".env"))'
+        return source if source.include?(dotenv_line)
+
+        lines = source.lines
+        require_line = lines.index { _1.match?(%r{^require ["']dotenv/load["']\s*$}) }
+        raise ArgumentError, 'project.rb must require dotenv/load before scaffolding demo users' unless require_line
+
+        lines.insert(require_line + 1, "#{dotenv_line}\n").join
+      end
+
+      def security_initialization_error
+        'project security is not initialized; run `mxrb security init Module` first'
+      end
+
+      def create_demo_user_file(name, entity, roles, password_env)
+        path = project_path('app', 'security', 'demo_users', "#{Templates.snake_case(name)}.rb")
+        @transaction.create(
+          path,
+          Templates.render(
+            :demo_user, name:, entity:, roles:, password_env:
+          )
+        )
+      end
+
+      def ensure_demo_user_secret(password_env)
+        path = project_path('.env')
+        source = @transaction.content(path)
+        if source
+          @transaction.write(path, append_env(source, password_env, generated_demo_password)) unless
+            env_key?(source, password_env)
+        else
+          create_demo_user_secret(path, password_env)
+        end
+        ensure_demo_user_env_example(password_env)
+      end
+
+      def create_demo_user_secret(path, password_env)
+        source = "# Local secrets; never commit this file.\n"
+        content = append_env(source, password_env, generated_demo_password)
+        @transaction.create(path, content, mode: 0o600)
+      end
+
+      def ensure_demo_user_env_example(password_env)
+        path = project_path('.env.example')
+        source = @transaction.content(path) || "# Copy to .env and keep real values local.\n"
+        @transaction.write(path, append_env(source, password_env, '')) unless env_key?(source, password_env)
+      end
+
+      def append_env(source, key, value)
+        "#{source.rstrip}\n#{key}=#{value}\n"
+      end
+
+      def env_key?(source, key)
+        source.lines.any? { _1.match?(/\A#{Regexp.escape(key)}=/) }
+      end
+
+      def generated_demo_password
+        "Mxrb#{SecureRandom.alphanumeric(16)}7"
+      end
+
+      def validate_demo_user_references!(name, entity, roles)
+        sources = project_ruby_sources
+        errors = []
+        missing_roles = roles - known_user_roles(sources)
+        errors << "missing user role(s): #{missing_roles.join(', ')}" unless missing_roles.empty?
+        errors << "missing user entity: #{entity}" unless
+          entity == 'System.User' || known_entities(sources).include?(entity)
+        return if errors.empty?
+
+        raise ArgumentError, "demo user #{name}: #{errors.join('; ')}"
+      end
+
+      def project_ruby_sources
+        Dir.glob(project_path('**', '*.rb')).to_h { [_1, File.read(_1)] }
+      end
+
+      def known_user_roles(sources)
+        pattern = /\buser_role\s+(?::([A-Za-z][A-Za-z0-9_]*)|["']([^"']+)["'])/
+        sources.values.flat_map { _1.scan(pattern).map { |match| match.compact.first } }.uniq
+      end
+
+      def known_entities(sources)
+        pattern = /\bentity\s+(?::([A-Za-z][A-Za-z0-9_]*)|["']([^"']+)["'])/
+        sources.flat_map do |path, source|
+          mod = path.match(%r{/modules/([^/]+)/})&.[](1)
+          mod ? source.scan(pattern).map { "#{mod}.#{_1.compact.first}" } : []
+        end.uniq
+      end
+
       def insert_before_closing(source, line, path)
         lines = source.lines
         closing = lines.rindex { _1.strip == 'end' }

data/lib/mxrb/scaffold/help.rb

@@ -23,6 +23,11 @@ module Mxrb
         'nanoflow' => ['new Module.Flow', 'Create a client nanoflow', 'presentation/client_actions'],
         'repository' => ['new Module.Repository', 'Create repository port and adapter', 'application/infrastructure'],
         'security' => ['init Module', 'Create module roles template', 'security'],
+        'demo-user' => [
+          'new NAME [--entity Module.Entity] [--role ROLE]',
+          'Create a local Mendix demo user backed by an ignored .env secret',
+          'app/security/demo_users'
+        ],
         'scheduled-event' => ['new Module.Event', 'Create scheduled event and handler', 'application/jobs'],
         'constant' => ['new Module.Constant', 'Create a string constant', 'domain/constants'],
         'integration' => ['new Module.Adapter', 'Create integration adapter flow', 'infrastructure/integrations'],
@@ -54,6 +59,14 @@ module Mxrb
           mxrb page templates [--json]
           --template starter|blank|dashboard|form-vertical
       HELP
+      DEMO_USER_OPTIONS = <<~HELP
+        Demo user options:
+          --entity Module.Entity   User entity (default: System.User)
+          --role ROLE              App user role (repeatable; default: User)
+
+        `new` is optional, so `mxrb demo-user manager ...` is also accepted.
+        The generated password is stored in the ignored .env file.
+      HELP
 
       def text(command)
         usage, description, destination = COMMANDS.fetch(command)
@@ -71,9 +84,10 @@ module Mxrb
       end
 
       def page_options(command)
-        return '' unless command == 'page'
+        return PAGE_OPTIONS if command == 'page'
+        return DEMO_USER_OPTIONS if command == 'demo-user'
 
-        PAGE_OPTIONS
+        ''
       end
     end
   end

data/lib/mxrb/scaffold/recipes.rb

@@ -129,6 +129,33 @@ module Mxrb
         connect_project_security(module_name)
       end
 
+      def scaffold_demo_user
+        ensure_project
+        name = identifier(@name, label: 'demo user')
+        entity = demo_user_entity
+        roles = demo_user_roles
+        validate_demo_user_references!(name, entity, roles)
+        password_env = "MXRB_DEMO_USER_#{name.gsub(/[^A-Za-z0-9]/, '_').upcase}_PASSWORD"
+
+        connect_project_demo_users
+        create_demo_user_file(name, entity, roles, password_env)
+        ensure_demo_user_secret(password_env) unless @dry_run
+      end
+
+      def demo_user_entity
+        entity = (@demo_entity || 'System.User').to_s
+        pattern = /\A[A-Za-z][A-Za-z0-9_]*\.[A-Za-z][A-Za-z0-9_]*\z/
+        raise ArgumentError, 'demo user entity must be qualified as Module.Entity' unless entity.match?(pattern)
+
+        entity
+      end
+
+      def demo_user_roles
+        roles = Array(@demo_roles)
+        roles = ['User'] if roles.empty?
+        roles.map { identifier(_1.to_s, label: 'user role') }.uniq
+      end
+
       def scaffold_functional_test
         module_name, artifact_name = qualified_name
         ensure_project

data/lib/mxrb/scaffold/templates.rb

@@ -293,6 +293,17 @@ module Mxrb
         RUBY
       end
 
+      def demo_user(_module_name, name, entity:, roles:, password_env:)
+        <<~RUBY
+          # frozen_string_literal: true
+
+          demo_user #{name.inspect},
+                    entity: #{entity.inspect},
+                    roles: #{roles.inspect},
+                    password: ENV.fetch(#{password_env.inspect})
+        RUBY
+      end
+
       def scheduled_event(module_name, name)
         <<~RUBY
           # frozen_string_literal: true

data/lib/mxrb/scaffold/transaction.rb

@@ -21,11 +21,11 @@ module Mxrb
         nil
       end
 
-      def create(path, content)
+      def create(path, content, mode: 0o644)
         abort "#{path}: file already exists" if File.exist?(path) || @changes.key?(path)
 
         @created << path
-        @changes[path] = Change.new(path, content, nil, 0o644)
+        @changes[path] = Change.new(path, content, nil, mode)
       end
 
       def write(path, new_content)

data/lib/mxrb/team_server.rb

@@ -161,7 +161,7 @@ module Mxrb
 
     # Git transport for Team Server. PATs are passed to a short-lived
     # GIT_ASKPASS process and are never embedded in a URL or git config.
-    class Repository
+    class Repository # rubocop:disable Metrics/ClassLength
       def initialize(credentials: Credentials.new, runner: CommandRunner.new,
                      authenticator: GitAuthenticator.new(credentials))
         @runner = runner
@@ -249,11 +249,14 @@ module Mxrb
       end
 
       def capture!(command, chdir: nil)
-        @authenticator.call do |environment|
-          output, status = @runner.capture(environment, command, chdir:)
-          raise TeamServerError, "Team Server Git operation failed: #{output.strip}" unless status.success?
-
-          output
+        Progress.with("Team Server #{command.first(2).join(' ')}") do |progress|
+          progress.update(detail: chdir || 'remote repository')
+          @authenticator.call do |environment|
+            output, status = @runner.capture(environment, command, chdir:)
+            raise TeamServerError, "Team Server Git operation failed: #{output.strip}" unless status.success?
+
+            output
+          end
         end
       end
 
@@ -285,7 +288,7 @@ module Mxrb
           mpr
         end
       end
-    end
+    end # rubocop:enable Metrics/ClassLength
 
     # Read-only client for Mendix's official App Repository API.
     class Api

data/lib/mxrb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mxrb
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/lib/mxrb/writer.rb

@@ -31,19 +31,32 @@ module Mxrb
     def initialize(path, definition)
       @path = File.expand_path(path)
       @definition = definition
+      @progress = Progress::NullTask.instance
     end
 
     def write!
-      create_project! unless File.exist?(@path)
-      mpr = IO::MprFile.open(@path)
-      mpr.transaction do
-        apply(mpr)
-        mpr.write_architecture_definition(@definition)
-      end
-      materialize_project_assets
-      materialize_design_system
+      mpr = nil
+      native_units = prepared_native_units
+      asset_manifest = project_asset_manifest
+      total = 4 + native_units.count { _1["containment"] != "Modules" } +
+              @definition.fetch(:modules).size + Array(asset_manifest&.fetch("files", [])).size
+      Progress.with("Generating #{File.basename(@path)}", total:) do |progress|
+        @progress = progress
+        create_project! unless File.exist?(@path)
+        progress.advance(detail: "project container")
+        mpr = IO::MprFile.open(@path)
+        mpr.transaction do
+          apply(mpr, native_units)
+          mpr.write_architecture_definition(@definition)
+        end
+        progress.advance(detail: "model transaction")
+        materialize_project_assets(asset_manifest)
+        materialize_design_system
+        progress.advance(detail: "design system")
+      end
       self
     ensure
+      @progress = Progress::NullTask.instance
       mpr&.close
     end
 
@@ -56,11 +69,17 @@ module Mxrb
       Model::DesignMaterializer.new(File.dirname(@path), design_system).materialize!
     end
 
-    def materialize_project_assets
+    def project_asset_manifest
       assets = @definition[:project_assets]
       return unless assets
 
-      manifest = JSON.parse(File.read(assets.fetch(:manifest)))
+      JSON.parse(File.read(assets.fetch(:manifest)))
+    end
+
+    def materialize_project_assets(manifest)
+      assets = @definition[:project_assets]
+      return unless assets && manifest
+
       source_root = File.realpath(assets.fetch(:root))
       target_root = File.dirname(@path)
       manifest.fetch("files").each do |entry|
@@ -79,6 +98,7 @@ module Mxrb
         FileUtils.mv(temporary, target)
       ensure
         FileUtils.rm_f(temporary) if temporary
+        @progress.advance(detail: "asset #{relative}") if defined?(relative) && relative
       end
     end
 
@@ -161,7 +181,7 @@ module Mxrb
       JSON.parse(File.read(path))["format_version"]
     end
 
-    def apply(mpr)
+    def apply(mpr, native_units)
       root = mpr.root_unit
       root_id = root.fetch("UnitID")
       root_doc = mpr.parse_contents(root)
@@ -171,10 +191,6 @@ module Mxrb
         "IsSystemProject" => false
       }
       mpr.update_unit(root_id, root_doc)
-      native_units = load_native_units(@definition[:native_units_path])
-      native_units = apply_native_unit_overrides(
-        native_units, @definition.fetch(:native_unit_overrides, [])
-      )
       apply_native_project_units(mpr, root_id, native_units)
       apply_default_project_units(mpr, root_id)
       ensure_project_documents(mpr, root_id)
@@ -194,9 +210,18 @@ module Mxrb
         write_module_security(mpr, module_id, mod) if mod.key?(:module_roles)
         write_domain_model(mpr, module_id, mod)
         write_documents(mpr, module_id, mod)
+        @progress.advance(detail: "module #{mod.fetch(:name)}")
       end
       write_project_security(mpr, root_id, @definition[:security]) if @definition[:security]
       write_project_navigation(mpr, root_id, @definition[:navigation]) if @definition[:navigation]
+      @progress.advance(detail: "project security and navigation")
+    end
+
+    def prepared_native_units
+      apply_native_unit_overrides(
+        load_native_units(@definition[:native_units_path]),
+        @definition.fetch(:native_unit_overrides, [])
+      )
     end
 
     def load_native_units(path)
@@ -323,8 +348,20 @@ module Mxrb
       mod.fetch(:native_documents, []).each do |document|
         doc = document.fetch(:doc)
         doc = legacy_layout_doc(doc) if doc['$Type'] == 'Forms$Layout' && legacy_layout?
+        existing = mpr.unit(document[:unit_id]) if document[:unit_id]
+        if existing
+          current = mpr.parse_contents(existing)
+          preserved = current.merge(doc).merge(
+            '$ID' => current['$ID'] || existing.fetch('UnitID'), '$Type' => doc.fetch('$Type')
+          )
+          mpr.update_unit(existing.fetch('UnitID'), preserved)
+          next
+        end
+
+        requested_container = document[:container_id]
+        target_container = requested_container && mpr.unit(requested_container) ? requested_container : module_id
         upsert_native_unit(
-          mpr, module_id,
+          mpr, target_container,
           'containment' => document.fetch(:containment), 'doc' => doc
         )
       end
@@ -365,7 +402,10 @@ module Mxrb
 
     def apply_native_unit_tree(mpr, target_root_id, units)
       if units.any? { _1["unit_id"].to_s.empty? || _1["container_id"].to_s.empty? }
-        units.each { upsert_native_unit(mpr, target_root_id, _1) }
+        units.each do |unit|
+          upsert_native_unit(mpr, target_root_id, unit)
+          @progress.advance(detail: "native unit #{unit['name']}")
+        end
         return
       end
 
@@ -382,6 +422,7 @@ module Mxrb
           target_container = mapped_containers.fetch(unit.fetch("container_id"))
           actual_id = upsert_native_unit(mpr, target_container, unit)
           mapped_containers[unit.fetch("unit_id")] = actual_id
+          @progress.advance(detail: "native unit #{unit['name']}")
         end
         pending = blocked
       end
@@ -441,6 +482,7 @@ module Mxrb
         end
         {
           demo_users_enabled: "EnableDemoUsers",
+          demo_users: "DemoUsers",
           guest_access_enabled: "EnableGuestAccess",
           guest_user_role: "GuestUserRole",
           sign_in_microflow: "SignInMicroflow",
@@ -1359,7 +1401,7 @@ module Mxrb
         previous&.dig(rules_key) || IO::BsonCodec.build_array([])
       end
       doc = (previous || {}).merge(
-        "$ID" => id, "$Type" => "DomainModels$EntityImpl",
+        "$ID" => id, "$Type" => previous&.fetch("$Type", nil) || "DomainModels$EntityImpl",
         "Name" => entity.fetch(:name), "Documentation" => entity.fetch(:documentation, ""),
         "GUID" => previous&.dig("GUID") || SecureRandom.uuid,
         "Location" => previous&.dig("Location") || "#{(index % 4) * 220};#{(index / 4) * 160}",
@@ -1367,6 +1409,7 @@ module Mxrb
         "IsRemote" => previous&.fetch("IsRemote", false) || false,
         "RemoteSource" => previous&.fetch("RemoteSource", "") || ""
       )
+      apply_oql_view!(doc, entity.fetch(:oql_view, nil), previous)
       doc[attrs_key] = IO::BsonCodec.build_array(attrs)
       doc[rules_key] = access_rules
       doc[validation_key] = validation_rules_doc(
@@ -1396,6 +1439,25 @@ module Mxrb
       doc
     end
 
+    def apply_oql_view!(doc, view, previous)
+      return unless view
+
+      if view[:source]
+        source_key = native_existing_key(previous, 'source', 'Source') || 'Source'
+        current_source = previous&.dig(source_key)
+        source = (current_source.is_a?(Hash) ? current_source : {}).merge(
+          '$ID' => current_source&.fetch('$ID', nil) || SecureRandom.uuid,
+          '$Type' => 'DomainModels$OqlViewEntitySource',
+          'SourceDocument' => view.fetch(:source)
+        )
+        doc[source_key] = source
+      end
+      return unless view[:query]
+
+      query_key = native_existing_key(previous, 'oqlQuery', 'OqlQuery', 'OQLQuery') || 'OqlQuery'
+      doc[query_key] = view.fetch(:query)
+    end
+
     def attribute_doc(attr, previous)
       storage_type = Model::Attribute::TYPE_MAP.fetch(attr.fetch(:type))
       type_key = native_existing_key(previous, "type", "Type", "newType", "NewType") || "NewType"
@@ -1923,7 +1985,9 @@ module Mxrb
         "StrictMode" => false,
         "StrictPageUrlCheck" => true,
         "UserRoles" => IO::BsonCodec.build_array(roles, marker: 2),
-        "DemoUsers" => IO::BsonCodec.build_array([], marker: 2),
+        "DemoUsers" => IO::BsonCodec.build_array(
+          Array(security[:demo_users]).map { demo_user_doc(_1) }, marker: 2
+        ),
         "FileDocumentAccess" => access_container("Security$FileDocumentAccessRuleContainer"),
         "ImageAccess" => access_container("Security$ImageAccessRuleContainer"),
         "PasswordPolicySettings" => password_policy
@@ -1945,6 +2009,17 @@ module Mxrb
       }
     end
 
+    def demo_user_doc(user)
+      {
+        "$ID" => SecureRandom.uuid,
+        "$Type" => "Security$DemoUserImpl",
+        "UserName" => user.fetch(:name),
+        "Password" => user.fetch(:password),
+        "Entity" => user.fetch(:entity),
+        "UserRoles" => IO::BsonCodec.build_array(user.fetch(:roles), marker: 1)
+      }
+    end
+
     def module_security_doc(roles, legacy: false)
       {
         "$ID" => SecureRandom.uuid,

data/lib/mxrb.rb

@@ -2,6 +2,7 @@
 
 require_relative "mxrb/version"
 require_relative "mxrb/errors"
+require_relative "mxrb/progress"
 require_relative "mxrb/doctor"
 require_relative "mxrb/benchmark"
 require_relative "mxrb/project_lifecycle"
@@ -126,6 +127,7 @@ require_relative "mxrb/runtime/docker_workspace"
 require_relative "mxrb/runtime/executor"
 require_relative "mxrb/runtime/native"
 require_relative "mxrb/runtime/docker_executor"
+require_relative "mxrb/runtime/clipboard"
 require_relative "mxrb/runtime/database_workspace"
 require_relative "mxrb/runtime/sql_server_database"
 require_relative "mxrb/oql/server"
@@ -138,14 +140,18 @@ module Mxrb
   #
   #   Mxrb.open("MyApp.mpr") { |p| puts p.modules.map(&:name) }
   #
-  def self.open(path, readonly: true, &block)
-    project = Model::Project.open(path, readonly: readonly)
-    return project unless block
+  def self.open(path, readonly: true, &block) # rubocop:disable Metrics/MethodLength
+    return Model::Project.open(path, readonly: readonly) unless block
 
-    begin
-      block.call(project)
-    ensure
-      project.close
+    Progress.with("Loading #{File.basename(path)}") do |progress|
+      progress.update(detail: "opening model")
+      project = Model::Project.open(path, readonly: readonly)
+      begin
+        progress.update(detail: "processing model")
+        block.call(project)
+      ensure
+        project.close
+      end
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mxrb
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Lucas Moura
@@ -372,9 +372,11 @@ files:
 - lib/mxrb/oql/sql_server_workload_analyzer.rb
 - lib/mxrb/oql/workload_analyzer.rb
 - lib/mxrb/oql/workload_baseline.rb
+- lib/mxrb/progress.rb
 - lib/mxrb/project_lifecycle.rb
 - lib/mxrb/protocols.rb
 - lib/mxrb/protocols/plan.rb
+- lib/mxrb/runtime/clipboard.rb
 - lib/mxrb/runtime/database_workspace.rb
 - lib/mxrb/runtime/docker_executor.rb
 - lib/mxrb/runtime/docker_workspace.rb