mendix-ruby-bridge 0.1.1

data/lib/mendix_bridge/migration.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+module MendixBridge
+  module Migration
+    Operation = Data.define(:action, :type, :name, :options) do
+      def to_h
+        { action:, type:, name:, options: }.compact
+      end
+    end
+
+    Plan = Data.define(:name, :operations) do
+      def to_h
+        { name:, operations: operations.map(&:to_h) }
+      end
+    end
+
+    class Builder
+      RENAMABLE_TYPES = %i[
+        entity microflow nanoflow page enumeration association constant module
+      ].freeze
+      DROPPABLE_TYPES = %i[
+        entity microflow nanoflow page enumeration association constant
+      ].freeze
+
+      def self.build(name, &block)
+        builder = new(name)
+        builder.instance_eval(&block)
+        builder.result
+      end
+
+      def initialize(name)
+        @name = name.to_s
+        @operations = []
+      end
+
+      def rename(type, name, to:)
+        type = checked_type(type, RENAMABLE_TYPES, "rename")
+        name = type == "module" ? identifier!(name) : qualified!(name)
+        add("rename", type, name, "to" => identifier!(to))
+      end
+
+      def drop(type, name)
+        type = checked_type(type, DROPPABLE_TYPES, "drop")
+        add("drop", type, qualified!(name))
+      end
+
+      def rename_attribute(entity, name, to:)
+        entity = qualified!(entity)
+        name = identifier!(name)
+        add(
+          "rename_attribute",
+          "attribute",
+          "#{entity}.#{name}",
+          "entity" => entity,
+          "attribute" => name,
+          "to" => identifier!(to)
+        )
+      end
+
+      def drop_attribute(entity, name)
+        entity = qualified!(entity)
+        name = identifier!(name)
+        add(
+          "drop_attribute",
+          "attribute",
+          "#{entity}.#{name}",
+          "entity" => entity,
+          "attribute" => name
+        )
+      end
+
+      def rename_enumeration_value(enumeration, name, to:)
+        enumeration = qualified!(enumeration)
+        name = identifier!(name)
+        add(
+          "rename_enumeration_value",
+          "enumeration_value",
+          "#{enumeration}.#{name}",
+          "enumeration" => enumeration,
+          "value" => name,
+          "to" => identifier!(to)
+        )
+      end
+
+      def drop_enumeration_value(enumeration, name)
+        enumeration = qualified!(enumeration)
+        name = identifier!(name)
+        add(
+          "drop_enumeration_value",
+          "enumeration_value",
+          "#{enumeration}.#{name}",
+          "enumeration" => enumeration,
+          "value" => name
+        )
+      end
+
+      def revoke_access(entity, role:)
+        entity = qualified!(entity)
+        role = qualified!(role)
+        add(
+          "revoke_access",
+          "entity_access",
+          "#{entity}:#{role}",
+          "entity" => entity,
+          "role" => role
+        )
+      end
+
+      def create_module(name)
+        add("create_module", "module", identifier!(name))
+      end
+
+      # Re-declares an existing association in place (UUID preserved by mxcli's
+      # CREATE OR MODIFY). Requires the full desired shape, not a delta.
+      def alter_association(name, from:, to:, type:, owner: "Default")
+        type = type.to_s
+        raise ArgumentError, "association type must be Reference or ReferenceSet" unless
+          %w[Reference ReferenceSet].include?(type)
+        owner = owner.to_s
+        raise ArgumentError, "association owner must be Default or Both" unless
+          %w[Default Both].include?(owner)
+
+        add(
+          "alter_association",
+          "association",
+          qualified!(name),
+          "from" => qualified!(from),
+          "to" => qualified!(to),
+          "type" => type,
+          "owner" => owner
+        )
+      end
+
+      # Changing an attribute's type has no in-place ALTER in MDL: it is an
+      # explicit DROP + ADD, which discards the column's data. That is why it
+      # lives here and not in the declarative apply.
+      def retype_attribute(entity, name, to:)
+        entity = qualified!(entity)
+        name = identifier!(name)
+        type = to.to_s.strip
+        raise ArgumentError, "retype target type cannot be empty" if type.empty?
+
+        add(
+          "retype_attribute",
+          "attribute",
+          "#{entity}.#{name}",
+          "entity" => entity,
+          "attribute" => name,
+          "type" => type
+        )
+      end
+
+      def alter_module_role(role, description:)
+        raise ArgumentError, "module role description cannot be empty" if
+          description.nil? || description.to_s.empty?
+
+        add(
+          "alter_module_role",
+          "modulerole",
+          qualified!(role),
+          "description" => description.to_s
+        )
+      end
+
+      def alter_user_role(name, module_roles:, manage_all_roles: false)
+        roles = Array(module_roles).map { |role| qualified!(role) }
+        raise ArgumentError, "user role requires at least one module role" if roles.empty?
+
+        add(
+          "alter_user_role",
+          "userrole",
+          identifier!(name),
+          "module_roles" => roles,
+          "manage_all_roles" => manage_all_roles ? true : false
+        )
+      end
+
+      def result
+        raise ArgumentError, "migration #{@name} requires at least one operation" if
+          @operations.empty?
+
+        Plan.new(name: @name, operations: @operations)
+      end
+
+      private
+
+      def checked_type(type, allowed, action)
+        type = type.to_sym
+        return type.to_s if allowed.include?(type)
+
+        raise ArgumentError,
+          "unsupported #{action} type #{type.inspect}; expected: #{allowed.join(', ')}"
+      end
+
+      def add(action, type, name, options = nil)
+        name = name.to_s
+        raise ArgumentError, "migration target cannot be empty" if name.empty?
+
+        @operations << Operation.new(action:, type:, name:, options:)
+      end
+
+      def identifier!(value)
+        value = value.to_s
+        return value if value.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
+
+        raise ArgumentError, "invalid Mendix identifier: #{value.inspect}"
+      end
+
+      def qualified!(value)
+        value = value.to_s
+        parts = value.split(".")
+        return value if parts.length == 2 && parts.all? do |part|
+          part.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
+        end
+
+        raise ArgumentError, "expected qualified Mendix name: #{value.inspect}"
+      end
+    end
+
+    class Generator
+      DROP_TYPES = {
+        "entity" => "ENTITY",
+        "microflow" => "MICROFLOW",
+        "nanoflow" => "NANOFLOW",
+        "page" => "PAGE",
+        "enumeration" => "ENUMERATION",
+        "association" => "ASSOCIATION",
+        "constant" => "CONSTANT"
+      }.freeze
+
+      def self.mdl(plan)
+        plan.operations.filter_map { |operation| statement(operation) }.join("\n")
+      end
+
+      def self.rename_operations(plan)
+        plan.operations.select { |operation| operation.action == "rename" }
+      end
+
+      def self.statement(operation)
+        options = operation.options || {}
+        case operation.action
+        when "rename" then nil
+        when "drop"
+          "DROP #{DROP_TYPES.fetch(operation.type)} #{operation.name};"
+        when "rename_attribute"
+          "ALTER ENTITY #{options.fetch('entity')} RENAME ATTRIBUTE " \
+            "#{options.fetch('attribute')} TO #{options.fetch('to')};"
+        when "drop_attribute"
+          "ALTER ENTITY #{options.fetch('entity')} DROP ATTRIBUTE " \
+            "#{options.fetch('attribute')};"
+        when "rename_enumeration_value"
+          "ALTER ENUMERATION #{options.fetch('enumeration')} RENAME VALUE " \
+            "#{options.fetch('value')} TO #{options.fetch('to')};"
+        when "drop_enumeration_value"
+          "ALTER ENUMERATION #{options.fetch('enumeration')} DROP VALUE " \
+            "#{options.fetch('value')};"
+        when "revoke_access"
+          "REVOKE #{options.fetch('role')} ON #{options.fetch('entity')};"
+        when "create_module"
+          "CREATE MODULE #{operation.name};"
+        when "alter_association"
+          "CREATE OR MODIFY ASSOCIATION #{operation.name}\n" \
+            "  FROM #{options.fetch('from')} TO #{options.fetch('to')}\n" \
+            "  TYPE #{options.fetch('type')}\n" \
+            "  OWNER #{options.fetch('owner')};"
+        when "retype_attribute"
+          "ALTER ENTITY #{options.fetch('entity')} DROP ATTRIBUTE " \
+            "#{options.fetch('attribute')};\n" \
+            "ALTER ENTITY #{options.fetch('entity')} ADD ATTRIBUTE " \
+            "#{options.fetch('attribute')}: #{options.fetch('type')};"
+        when "alter_module_role"
+          "ALTER MODULE ROLE #{operation.name} " \
+            "DESCRIPTION '#{escape(options.fetch('description'))}';"
+        when "alter_user_role"
+          management = options["manage_all_roles"] ? " MANAGE ALL ROLES" : ""
+          "ALTER USER ROLE #{operation.name} " \
+            "(#{options.fetch('module_roles').join(', ')})#{management};"
+        else
+          raise ArgumentError, "unsupported migration action: #{operation.action}"
+        end
+      end
+
+      def self.escape(value)
+        value.to_s.gsub("'", "''")
+      end
+
+      private_class_method :statement, :escape
+    end
+  end
+end

data/lib/mendix_bridge/migration_executor.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "open3"
+require "securerandom"
+require "tempfile"
+require "time"
+
+module MendixBridge
+  class MigrationError < StandardError; end
+
+  class MigrationExecutor
+    Result = Data.define(:backup_dir, :operations)
+
+    def initialize(mxcli:)
+      @mxcli = File.expand_path(mxcli)
+    end
+
+    def apply(plan, project_file:, confirmation:, studio_closed:)
+      project_file = File.expand_path(project_file)
+      validate!(plan, project_file, confirmation, studio_closed)
+      project_dir = File.dirname(project_file)
+      ensure_clean_git!(project_dir)
+      validate_operations!(plan, project_file)
+      backup_dir = create_backup(plan, project_file)
+
+      begin
+        apply_renames!(plan, project_file)
+        apply_mdl!(plan, project_file)
+        check_project!(project_file)
+      rescue StandardError => error
+        begin
+          restore_backup!(backup_dir, project_file)
+          check_project!(project_file)
+        rescue StandardError => restore_error
+          raise MigrationError,
+            "migration failed and automatic restore also failed; " \
+            "backup is #{backup_dir}: #{restore_error.message}"
+        end
+        raise MigrationError,
+          "migration failed and backup was restored: #{error.message}"
+      end
+
+      Result.new(backup_dir:, operations: plan.operations.length)
+    end
+
+    def restore(backup_dir, project_file:, confirmation:, studio_closed:)
+      backup_dir = File.expand_path(backup_dir)
+      project_file = File.expand_path(project_file)
+      manifest = read_manifest(backup_dir)
+      expected = File.basename(backup_dir)
+      raise MigrationError, "confirmation must exactly match #{expected}" unless
+        confirmation == expected
+      raise MigrationError, "--studio-closed is required" unless studio_closed
+      unless File.expand_path(manifest.fetch("project_file")) == project_file
+        raise MigrationError, "backup belongs to another Mendix project"
+      end
+
+      restore_backup!(backup_dir, project_file)
+      check_project!(project_file)
+      true
+    end
+
+    private
+
+    def validate!(plan, project_file, confirmation, studio_closed)
+      raise MigrationError, "Mendix project does not exist: #{project_file}" unless
+        File.file?(project_file)
+      raise MigrationError, "mxcli is not executable: #{@mxcli}" unless
+        File.executable?(@mxcli)
+      raise MigrationError, "--studio-closed is required" unless studio_closed
+      unless confirmation == plan.name
+        raise MigrationError, "confirmation must exactly match migration name #{plan.name}"
+      end
+    end
+
+    def ensure_clean_git!(project_dir)
+      root = run!(
+        "git", "-C", project_dir, "rev-parse", "--show-toplevel",
+        error_prefix: "Mendix project must be inside a Git repository"
+      ).strip
+      status = run!(
+        "git", "-C", root, "status", "--porcelain",
+        error_prefix: "could not inspect Git status"
+      )
+      raise MigrationError, "target repository has uncommitted changes" unless status.empty?
+    end
+
+    def validate_operations!(plan, project_file)
+      Migration::Generator.rename_operations(plan).each do |operation|
+        options = operation.options.fetch("to")
+        run!(
+          @mxcli,
+          "rename",
+          "-p", project_file,
+          operation.type,
+          operation.name,
+          options,
+          "--dry-run",
+          error_prefix: "rename preview failed for #{operation.name}"
+        )
+      end
+
+      mdl = Migration::Generator.mdl(plan)
+      return if mdl.empty?
+
+      with_mdl(mdl) do |path|
+        run!(
+          @mxcli,
+          "check", path,
+          error_prefix: "migration MDL is invalid"
+        )
+      end
+    end
+
+    def create_backup(plan, project_file)
+      project_dir = File.dirname(project_file)
+      id = "#{Time.now.utc.strftime('%Y%m%dT%H%M%SZ')}-" \
+        "#{safe_name(plan.name)}-#{SecureRandom.hex(3)}"
+      backup_root = run!(
+        "git",
+        "-C", project_dir,
+        "rev-parse",
+        "--path-format=absolute",
+        "--git-path", "mendix-ruby-backups",
+        error_prefix: "could not locate Git backup storage"
+      ).strip
+      backup_dir = File.join(backup_root, id)
+      FileUtils.mkdir_p(backup_dir)
+      FileUtils.cp(project_file, File.join(backup_dir, File.basename(project_file)))
+      contents = File.join(project_dir, "mprcontents")
+      FileUtils.cp_r(contents, File.join(backup_dir, "mprcontents")) if Dir.exist?(contents)
+      File.write(
+        File.join(backup_dir, "manifest.json"),
+        "#{JSON.pretty_generate(
+          "migration" => plan.name,
+          "project_file" => project_file,
+          "created_at" => Time.now.utc.iso8601,
+          "operations" => plan.operations.map(&:to_h)
+        )}\n"
+      )
+      backup_dir
+    end
+
+    def apply_renames!(plan, project_file)
+      Migration::Generator.rename_operations(plan).each do |operation|
+        run!(
+          @mxcli,
+          "rename",
+          "-p", project_file,
+          operation.type,
+          operation.name,
+          operation.options.fetch("to"),
+          error_prefix: "could not rename #{operation.name}"
+        )
+      end
+    end
+
+    def apply_mdl!(plan, project_file)
+      mdl = Migration::Generator.mdl(plan)
+      return if mdl.empty?
+
+      with_mdl(mdl) do |path|
+        run!(
+          @mxcli,
+          "exec", path,
+          "-p", project_file,
+          error_prefix: "could not apply migration MDL"
+        )
+      end
+    end
+
+    def check_project!(project_file)
+      version_file = File.join(File.dirname(project_file), ".mendix-version")
+      raise MigrationError, "missing #{version_file}" unless File.file?(version_file)
+
+      version = File.read(version_file).strip
+      mx = File.join(Dir.home, ".mxcli", "mxbuild", version, "modeler", "mx")
+      raise MigrationError, "Mendix mx #{version} is not installed" unless File.executable?(mx)
+
+      run!(
+        mx,
+        "check",
+        project_file,
+        chdir: File.dirname(project_file),
+        error_prefix: "official Mendix consistency check failed"
+      )
+    end
+
+    def restore_backup!(backup_dir, project_file)
+      manifest = read_manifest(backup_dir)
+      source_project = File.join(backup_dir, File.basename(manifest.fetch("project_file")))
+      FileUtils.cp(source_project, project_file)
+
+      project_contents = File.join(File.dirname(project_file), "mprcontents")
+      backup_contents = File.join(backup_dir, "mprcontents")
+      FileUtils.rm_rf(project_contents)
+      FileUtils.cp_r(backup_contents, project_contents) if Dir.exist?(backup_contents)
+    end
+
+    def read_manifest(backup_dir)
+      path = File.join(backup_dir, "manifest.json")
+      raise MigrationError, "invalid migration backup: #{backup_dir}" unless File.file?(path)
+
+      JSON.parse(File.read(path))
+    end
+
+    def safe_name(name)
+      name.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/\A-|-\z/, "")
+    end
+
+    def with_mdl(mdl)
+      Tempfile.create(["mendix-ruby-migration-", ".mdl"]) do |file|
+        file.write(mdl)
+        file.flush
+        yield file.path
+      end
+    end
+
+    def run!(*command, chdir: nil, error_prefix:)
+      stdout, stderr, status = if chdir
+        Open3.capture3(*command, chdir:)
+      else
+        Open3.capture3(*command)
+      end
+      return stdout if status.success?
+
+      detail = stderr.strip
+      detail = stdout.strip if detail.empty?
+      raise MigrationError, "#{error_prefix}: #{detail}"
+    end
+  end
+end