mxrb 0.1.0

data/lib/mxrb/marketplace.rb

@@ -0,0 +1,380 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "json"
+require "net/http"
+require "open3"
+require "pathname"
+require "tmpdir"
+require "uri"
+
+module Mxrb
+  module Marketplace
+    Entry = Data.define(:name, :version, :description, :source, :ref)
+    Installation = Data.define(:entry, :module_name, :destination, :digest)
+
+    class Catalog
+      DEFAULT_PATH = File.expand_path("../../marketplace/catalog.json", __dir__)
+
+      def initialize(source = nil)
+        @source = source || DEFAULT_PATH
+      end
+
+      def entries
+        @entries ||= begin
+          payload = JSON.parse(read_source)
+          Array(payload.fetch("modules")).map do |item|
+            Entry.new(
+              item.fetch("name"), item.fetch("version"),
+              item.fetch("description", ""), item.fetch("source"),
+              item["ref"]
+            )
+          end.freeze
+        rescue JSON::ParserError, KeyError => e
+          raise MarketplaceError, "invalid marketplace catalog: #{e.message}"
+        end
+      end
+
+      def search(query = nil)
+        term = query.to_s.downcase
+        return entries if term.empty?
+
+        entries.select do |entry|
+          [entry.name, entry.description].any? { _1.downcase.include?(term) }
+        end
+      end
+
+      def find(name)
+        entries.find { _1.name == name.to_s } ||
+          raise(MarketplaceError, "module #{name.inspect} was not found in the catalog")
+      end
+
+      def find_version(name, version)
+        entries.find { _1.name == name.to_s && _1.version == version.to_s } ||
+          raise(MarketplaceError, "module #{name.inspect} version #{version.inspect} was not found in the catalog")
+      end
+
+      private
+
+      def read_source
+        uri = URI.parse(@source.to_s)
+        return File.read(@source) unless uri.is_a?(URI::HTTP)
+        raise MarketplaceError, "marketplace catalogs must use HTTPS" unless uri.is_a?(URI::HTTPS)
+
+        response = Net::HTTP.get_response(uri)
+        raise MarketplaceError, "catalog request failed with HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+        response.body
+      rescue URI::InvalidURIError, Errno::ENOENT => e
+        raise MarketplaceError, "cannot read marketplace catalog: #{e.message}"
+      end
+    end
+
+    class Installer
+      MANIFEST = "mxrb-module.json"
+
+      def initialize(target:, catalog: Catalog.new)
+        @target = File.expand_path(target)
+        @catalog = catalog
+      end
+
+      def install(identifier, version: nil)
+        install_package(identifier, version: version, replace: false)
+      end
+
+      def update(identifier, version: nil)
+        installed_module_name = resolve_installed_module_name(identifier)
+        install_package(
+          identifier,
+          version: version,
+          replace: true,
+          installed_module_name: installed_module_name
+        )
+      end
+
+      def remove(identifier)
+        module_name = resolve_installed_module_name(identifier)
+        validate_no_dependents!(module_name)
+        destination = File.join(@target, "modules", module_name)
+        FileUtils.rm_rf(destination) if File.exist?(destination)
+        remove_from_lock(module_name)
+        module_name
+      end
+
+      private
+
+      def install_package(identifier, version:, replace:, installed_module_name: nil)
+        entry, source = resolve(identifier, version: version)
+        Dir.mktmpdir("mxrb-module-") do |workspace|
+          package = materialize(source, entry, workspace)
+          manifest = load_manifest(package)
+          module_name = valid_name(manifest.fetch("module_name"))
+          destination = File.join(@target, "modules", module_name)
+          if installed_module_name && module_name != installed_module_name
+            raise MarketplaceError,
+                  "module update cannot change its name from #{installed_module_name.inspect} to #{module_name.inspect}"
+          end
+          if File.exist?(destination) && !replace
+            raise MarketplaceError, "module destination already exists: #{destination}"
+          end
+
+          manifest_name = manifest["name"].to_s
+          canonical_entry = manifest_name.empty? ? entry : Entry.new(
+            manifest_name, entry.version, entry.description, entry.source, entry.ref
+          )
+          validate_mendix_version!(manifest)
+          validate_dependencies!(manifest)
+          files = package_files(package, manifest)
+          staging = File.join(@target, ".mxrb", "staging", "#{module_name}-#{Process.pid}")
+          backup = nil
+          FileUtils.mkdir_p(staging)
+          files.each { copy_entry(package, staging, _1) }
+          if replace && File.exist?(destination)
+            backup = File.join(@target, ".mxrb", "backup", "#{module_name}-#{Process.pid}")
+            FileUtils.mkdir_p(File.dirname(backup))
+            FileUtils.mv(destination, backup)
+          end
+          FileUtils.mkdir_p(File.dirname(destination))
+          FileUtils.mv(staging, destination)
+          FileUtils.rm_rf(backup) if backup
+          backup = nil
+          digest = tree_digest(destination)
+          write_lock(canonical_entry, module_name, digest, dependencies: declared_dependencies(manifest))
+          Installation.new(entry, module_name, destination, digest)
+        rescue StandardError
+          FileUtils.mv(backup, destination) if backup && File.exist?(backup) && !File.exist?(destination)
+          raise
+        ensure
+          FileUtils.rm_rf(staging) if staging && File.exist?(staging)
+          FileUtils.rm_rf(backup) if backup && File.exist?(backup)
+        end
+      rescue KeyError, JSON::ParserError => e
+        raise MarketplaceError, "invalid module manifest: #{e.message}"
+      end
+
+      def resolve(identifier, version: nil)
+        path = File.expand_path(identifier.to_s)
+        return [local_entry(path), path] if File.directory?(path)
+
+        entry = version ? @catalog.find_version(identifier, version) : @catalog.find(identifier)
+        [entry, entry.source]
+      end
+
+      def resolve_installed_module_name(identifier)
+        lock_path = File.join(@target, ".mxrb", "modules.lock.json")
+        raise MarketplaceError, "no modules are installed (lock file missing)" unless File.file?(lock_path)
+
+        lock = JSON.parse(File.read(lock_path))
+        locked = lock.fetch("modules", {})
+        entry = locked.find { |_name, info| info["package"] == identifier.to_s }
+        unless entry
+          candidates = locked.select { |name, _| name.downcase == identifier.to_s.downcase }
+          entry = candidates.first
+        end
+        raise MarketplaceError, "module #{identifier.inspect} is not installed" unless entry
+
+        entry.first
+      end
+
+      def remove_from_lock(module_name)
+        lock_path = File.join(@target, ".mxrb", "modules.lock.json")
+        return unless File.file?(lock_path)
+
+        lock = JSON.parse(File.read(lock_path))
+        lock.fetch("modules", {}).delete(module_name)
+        temporary = "#{lock_path}.tmp-#{Process.pid}"
+        File.write(temporary, JSON.pretty_generate(lock) << "\n")
+        File.rename(temporary, lock_path)
+      ensure
+        FileUtils.rm_f(temporary) if defined?(temporary) && temporary && File.exist?(temporary)
+      end
+
+      def local_entry(path)
+        Entry.new(File.basename(path), "local", "Local MXRB module", path, nil)
+      end
+
+      def materialize(source, entry, workspace)
+        return builtin_path(source) if source.start_with?("builtin:")
+        return File.expand_path(source) if File.directory?(source)
+
+        destination = File.join(workspace, "repository")
+        command = ["git", "clone", "--depth", "1"]
+        command += ["--branch", entry.ref] if entry.ref
+        command += [source, destination]
+        output, status = Open3.capture2e(*command)
+        raise MarketplaceError, "could not fetch #{entry.name}: #{output}" unless status.success?
+
+        destination
+      end
+
+      def builtin_path(source)
+        slug = source.delete_prefix("builtin:")
+        unless slug.match?(/\A[a-z0-9]+(?:-[a-z0-9]+)*\z/)
+          raise MarketplaceError, "invalid built-in module slug #{slug.inspect}"
+        end
+        path = File.expand_path("../../marketplace/modules/#{slug}", __dir__)
+        raise MarketplaceError, "built-in module #{slug.inspect} is unavailable" unless File.directory?(path)
+
+        path
+      end
+
+      def load_manifest(package)
+        JSON.parse(File.read(File.join(package, MANIFEST)))
+      rescue Errno::ENOENT => e
+        raise MarketplaceError, "module manifest is missing: #{e.message}"
+      end
+
+      def valid_name(value)
+        name = value.to_s
+        unless name.match?(/\A[A-Za-z][A-Za-z0-9_]*\z/)
+          raise MarketplaceError, "invalid module name #{name.inspect}"
+        end
+
+        name
+      end
+
+      def package_files(package, manifest)
+        files = Array(manifest["files"] || Dir.children(package) - [MANIFEST])
+        raise MarketplaceError, "module package has no files" if files.empty?
+
+        files.each do |relative|
+          path = Pathname.new(relative.to_s)
+          if path.absolute? || path.each_filename.any? { _1 == ".." }
+            raise MarketplaceError, "unsafe module path #{relative.inspect}"
+          end
+          raise MarketplaceError, "module file is missing: #{relative}" unless File.exist?(File.join(package, relative))
+        end
+        files
+      end
+
+      def copy_entry(package, staging, relative)
+        source = File.join(package, relative)
+        destination = File.join(staging, relative)
+        FileUtils.mkdir_p(File.dirname(destination))
+        FileUtils.cp_r(source, destination)
+      end
+
+      def tree_digest(path)
+        digest = Digest::SHA256.new
+        Dir.glob(File.join(path, "**", "*"), File::FNM_DOTMATCH).sort.each do |file|
+          next unless File.file?(file)
+
+          digest << file.delete_prefix("#{path}/") << "\0" << File.binread(file)
+        end
+        digest.hexdigest
+      end
+
+      def declared_dependencies(manifest)
+        Array(manifest["dependencies"]).map do |dep|
+          name = dep.is_a?(Hash) ? dep["name"].to_s : dep.to_s
+          name unless name.empty?
+        end.compact
+      end
+
+      def validate_dependencies!(manifest)
+        deps = declared_dependencies(manifest)
+        return if deps.empty?
+
+        lock_path = File.join(@target, ".mxrb", "modules.lock.json")
+        installed_packages = if File.file?(lock_path)
+          JSON.parse(File.read(lock_path)).fetch("modules", {}).values.map { _1["package"] }
+        else
+          []
+        end
+        missing = deps.reject { |dep| installed_packages.include?(dep) }
+        return if missing.empty?
+
+        raise MarketplaceError,
+              "missing dependencies: #{missing.join(', ')} — install them first"
+      end
+
+      def validate_mendix_version!(manifest)
+        required = manifest["mendix_version"].to_s.strip
+        return if required.empty?
+
+        project_version = detect_project_mendix_version
+        return if project_version.nil?
+
+        unless mendix_version_compatible?(project_version, required)
+          raise MarketplaceError,
+                "module requires Mendix #{required}, but the project uses #{project_version}"
+        end
+      end
+
+      def detect_project_mendix_version
+        mpr_files = Dir.glob(File.join(@target, "*.mpr"))
+        return nil if mpr_files.empty?
+
+        require_relative "../mxrb/io/mpr_file"
+        mpr = IO::MprFile.open(mpr_files.first, readonly: true)
+        mpr.mendix_version
+      rescue StandardError
+        nil
+      ensure
+        mpr&.close
+      end
+
+      def mendix_version_compatible?(project_version, required)
+        proj_parts = project_version.to_s.split(".").map(&:to_i)
+        req_str    = required.to_s.strip
+
+        case req_str
+        when /\A(\d+)\.x\z/
+          proj_parts[0] == ::Regexp.last_match(1).to_i
+        when /\A>=\s*(.+)\z/
+          version_gte?(proj_parts, ::Regexp.last_match(1).strip.split(".").map(&:to_i))
+        when /\A~>\s*(.+)\z/
+          base = ::Regexp.last_match(1).strip.split(".").map(&:to_i)
+          version_gte?(proj_parts, base) &&
+            proj_parts[0, base.size - 1] == base[0, base.size - 1]
+        else
+          project_version.start_with?(req_str.sub(/\.\*\z/, ""))
+        end
+      end
+
+      def version_gte?(a, b)
+        a.zip(b).each do |av, bv|
+          av ||= 0
+          bv ||= 0
+          return true  if av > bv
+          return false if av < bv
+        end
+        true
+      end
+
+      def validate_no_dependents!(module_name)
+        lock_path = File.join(@target, ".mxrb", "modules.lock.json")
+        return unless File.file?(lock_path)
+
+        lock = JSON.parse(File.read(lock_path))
+        package_name = lock.dig("modules", module_name, "package")
+        return unless package_name
+
+        dependents = lock.fetch("modules", {}).filter_map do |name, info|
+          name if name != module_name && Array(info["dependencies"]).include?(package_name)
+        end
+        return if dependents.empty?
+
+        raise MarketplaceError,
+              "cannot remove #{module_name.inspect}: #{dependents.join(', ')} depend on it"
+      end
+
+      def write_lock(entry, module_name, digest, dependencies: [])
+        lock_path = File.join(@target, ".mxrb", "modules.lock.json")
+        FileUtils.mkdir_p(File.dirname(lock_path))
+        lock = File.file?(lock_path) ? JSON.parse(File.read(lock_path)) : { "modules" => {} }
+        lock["modules"][module_name] = {
+          "package" => entry.name, "version" => entry.version,
+          "source" => entry.source, "ref" => entry.ref, "sha256" => digest,
+          "dependencies" => dependencies.empty? ? nil : dependencies
+        }.compact
+        temporary = "#{lock_path}.tmp-#{Process.pid}"
+        File.write(temporary, JSON.pretty_generate(lock) << "\n")
+        File.rename(temporary, lock_path)
+      ensure
+        FileUtils.rm_f(temporary) if temporary && File.exist?(temporary)
+      end
+    end
+  end
+end

data/lib/mxrb/model/association.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Mxrb
+  module Model
+    # Associations are embedded in DomainModel BSON — NOT separate Unit rows.
+    # $Type: DomainModels$Association
+    #
+    # CRITICAL GOTCHA (from reverse engineering):
+    #   ParentID = entity FROM (the one with the FK) — counter-intuitive naming!
+    #   ChildID  = entity TO  (the referenced entity)
+    # MemberAccess should be added ONLY to the FROM entity (ParentPointer), not ChildID.
+    class Association
+      attr_accessor :id, :name, :documentation,
+                    :from_entity_id,   # ParentID in BSON (FROM entity — has the FK)
+                    :to_entity_id,     # ChildID  in BSON (TO entity — referenced)
+                    :association_type, :owner, :storage_format,
+                    :delete_behavior, :export_level
+
+      TYPES         = %i[Reference ReferenceSet].freeze
+      OWNERS        = %i[Default Both].freeze
+      STORAGE_FMTS  = %i[Column Table].freeze
+
+      def self.from_bson(doc, _domain_model_id = nil, _mpr = nil)
+        a                  = new
+        a.id               = IO::BsonCodec.extract_id(doc["$ID"] || doc["\$ID"])
+        a.name             = doc["Name"] || doc["name"]
+        a.documentation    = doc["Documentation"] || doc["documentation"] || ""
+        # ParentID = FROM entity (counter-intuitive — see class comment)
+        a.from_entity_id   = IO::BsonCodec.extract_id(
+          doc["ParentPointer"] || doc["ParentID"] || doc["parentId"]
+        )
+        child = doc['Child'] || doc["ChildPointer"] || doc["ChildID"] || doc["childId"]
+        a.to_entity_id = if child.is_a?(String) && child.include?('.')
+                           child
+                         else
+                           IO::BsonCodec.extract_id(child)
+                         end
+        a.association_type = (doc["Type"] || doc["type"] || "Reference").to_sym
+        a.owner            = (doc["Owner"] || doc["owner"] || "Default").to_sym
+        a.storage_format   = (doc["StorageFormat"] || "Column").to_sym
+        a.delete_behavior  = doc["DeleteBehavior"] || doc["deleteBehavior"]
+        a.export_level     = doc["ExportLevel"] || "Hidden"
+        a
+      end
+
+      def to_bson
+        {
+          "$ID"           => @id || SecureRandom.uuid,
+          "$Type"         => "DomainModels$Association",
+          "Name"          => @name,
+          "Documentation" => @documentation || "",
+          # ParentID = FROM entity (the one that carries the FK)
+          "ParentID"      => @from_entity_id,
+          "ChildID"       => @to_entity_id,
+          "Type"          => (@association_type || :Reference).to_s,
+          "Owner"         => (@owner || :Default).to_s,
+          "StorageFormat" => (@storage_format || :Column).to_s,
+          "DeleteBehavior" => @delete_behavior || default_delete_behavior,
+          "ExportLevel"   => @export_level || "Hidden",
+        }
+      end
+
+      def inspect
+        "#<Mxrb::Association name=#{@name.inspect} type=#{@association_type} " \
+          "from=#{@from_entity_id.to_s.slice(0, 8)} to=#{@to_entity_id.to_s.slice(0, 8)}>"
+      end
+
+      def parent_delete_behavior
+        behavior_value('parentDeleteBehavior', 'ParentDeleteBehavior')
+      end
+
+      def child_delete_behavior
+        behavior_value('childDeleteBehavior', 'ChildDeleteBehavior')
+      end
+
+      private
+
+      def behavior_value(lower, upper)
+        return :NoAction unless @delete_behavior.is_a?(Hash)
+
+        (@delete_behavior[lower] || @delete_behavior[upper] || 'NoAction').to_sym
+      end
+
+      def default_delete_behavior
+        {
+          "$ID"   => SecureRandom.uuid,
+          "$Type" => "DomainModels$DeleteBehavior",
+          "parentDeleteBehavior" => "NoAction",
+          "childDeleteBehavior"  => "NoAction",
+          "parentErrorMessage"   => nil,
+          "childErrorMessage"    => nil,
+        }
+      end
+    end
+  end
+end

data/lib/mxrb/model/attribute.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Mxrb
+  module Model
+    # Attributes are embedded in Entity BSON — NOT separate Unit rows.
+    # $Type: DomainModels$Attribute
+    class Attribute
+      # Maps DSL symbol → Mendix storage type name
+      TYPE_MAP = {
+        string:      "DomainModels$StringAttributeType",
+        integer:     "DomainModels$IntegerAttributeType",
+        long:        "DomainModels$LongAttributeType",
+        float:       "DomainModels$FloatAttributeType",
+        decimal:     "DomainModels$DecimalAttributeType",
+        boolean:     "DomainModels$BooleanAttributeType",
+        datetime:    "DomainModels$DateTimeAttributeType",
+        autonumber:  "DomainModels$AutoNumberAttributeType",
+        hashstring:  "DomainModels$HashedStringAttributeType",
+        binary:      "DomainModels$BinaryAttributeType",
+        enum:        "DomainModels$EnumerationAttributeType",
+      }.freeze
+
+      REVERSE_TYPE_MAP = TYPE_MAP.invert.freeze
+
+      attr_accessor :id, :name, :documentation, :type, :default_value,
+                    :data_storage_guid, :export_level, :raw_type_doc, :raw_value_doc,
+                    :length, :localize_date, :enumeration, :required, :unique
+
+      def self.from_bson(doc)
+        a                   = new
+        a.id                = IO::BsonCodec.extract_id(doc["$ID"] || doc["\$ID"])
+        a.name              = doc["name"]  || doc["Name"]
+        a.documentation     = doc["documentation"] || doc["Documentation"] || ""
+        a.data_storage_guid = doc["dataStorageGuid"] || doc["DataStorageGuid"]
+        a.export_level      = doc["exportLevel"] || doc["ExportLevel"] || "Hidden"
+
+        type_doc = doc["type"] || doc["Type"] || doc["newType"] || doc["NewType"]
+        a.raw_type_doc = type_doc
+        if type_doc.is_a?(Hash)
+          storage_type = type_doc["$Type"] || type_doc["\$Type"]
+          a.type = REVERSE_TYPE_MAP[storage_type] || :string
+          a.length = type_doc['length'] || type_doc['Length']
+          a.localize_date = if type_doc.key?('localizeDate')
+                              type_doc['localizeDate']
+                            else
+                              type_doc['LocalizeDate']
+                            end
+          a.enumeration = type_doc['enumeration'] || type_doc['Enumeration']
+        else
+          a.type = :string
+        end
+
+        a.raw_value_doc = doc["value"] || doc["Value"]
+        a.default_value = extract_default(a.raw_value_doc)
+        a
+      end
+
+      def to_bson
+        {
+          "$ID"             => @id || SecureRandom.uuid,
+          "$Type"           => "DomainModels$Attribute",
+          "name"            => @name,
+          "documentation"   => @documentation || "",
+          "dataStorageGuid" => @data_storage_guid || SecureRandom.uuid,
+          "exportLevel"     => @export_level || "Hidden",
+          "type"            => serialize_type,
+          "value"           => serialize_value,
+        }
+      end
+
+      def inspect
+        "#<Mxrb::Attribute name=#{@name.inspect} type=#{@type}>"
+      end
+
+      private
+
+      def self.extract_default(value_doc)
+        return nil unless value_doc.is_a?(Hash)
+        value_doc["defaultValue"] || value_doc["DefaultValue"]
+      end
+
+      def serialize_type
+        storage_type = TYPE_MAP[@type] || TYPE_MAP[:string]
+        base = { "$ID" => SecureRandom.uuid, "$Type" => storage_type }
+        base["localizeDate"] = true if @type == :datetime
+        base
+      end
+
+      def serialize_value
+        {
+          "$ID"          => SecureRandom.uuid,
+          "$Type"        => "DomainModels$StoredValue",
+          "defaultValue" => @default_value.to_s,
+        }
+      end
+    end
+  end
+end

data/lib/mxrb/model/connector.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Model
+    # A marketplace connector detected inside a project.
+    #
+    # MXRB never runs the connector; it only represents the public surface that
+    # the semantic index can observe. Protected or non-decodable internals are
+    # reported as unavailable (empty), never guessed.
+    Connector = Data.define(
+      :module_name, :protocol, :appstore_guid, :appstore_version,
+      :entities, :microflows, :protected, :metadata
+    ) do
+      def known? = !protocol.nil?
+    end
+  end
+end